[client] Route agent-network through the daemon and shape env per provider

Two field-test findings drive this change: the direct-dial path needed
sudo (the profile's WireGuard key is root-owned), and a single flat
ANTHROPIC_* export set is wrong for providers that speak other API
shapes.

Relay the setup request through the daemon instead: a new
GetAgentNetworkSetup daemon RPC forwards to management over the
engine's existing peer connection, so unprivileged callers get the
caller-scoped answer the same way 'netbird status' works — no sudo,
and the key never leaves the daemon. The daemon's JSON gateway exposes
the RPC for the desktop UI for free.

Teach 'agent-network env' the per-provider environment contracts,
mirroring Claude Code's LLM-gateway configuration:
- anthropic flavor: ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN /
  ANTHROPIC_MODEL
- bedrock_api: CLAUDE_CODE_USE_BEDROCK, ANTHROPIC_BEDROCK_BASE_URL,
  CLAUDE_CODE_SKIP_BEDROCK_AUTH (the proxy injects AWS credentials)
- vertex_ai_api: CLAUDE_CODE_USE_VERTEX, ANTHROPIC_VERTEX_BASE_URL,
  CLAUDE_CODE_SKIP_VERTEX_AUTH, plus comments for the admin-supplied
  ANTHROPIC_VERTEX_PROJECT_ID and CLOUD_ML_REGION (the proxy forwards
  the URL path, so those values must be the operator's real ones)
- openai flavor: OPENAI_BASE_URL / OPENAI_API_KEY
- anything else: comment lines only — no guessed variables

Selection stays explicit: --provider picks by operator label or
catalog id and is required when several providers are authorized;
--model is validated against the provider's allowed set and required
when several models are allowed. Ambiguity renders as shell comments,
never as exports.

Linear: NET-1399

.goreleaser_ui.yaml

@@ -92,11 +92,6 @@ nfpms:
         dst: /usr/share/applications/org.wails.netbird.desktop
       - src: client/ui/build/appicon.png
         dst: /usr/share/pixmaps/netbird.png
-      # Names the polkit action for the elevation prompt the app raises when an
-      # unprivileged user changes a privileged setting; without it the dialog
-      # shows a raw command line.
-      - src: client/ui/build/linux/polkit/io.netbird.settings.policy
-        dst: /usr/share/polkit-1/actions/io.netbird.settings.policy
     dependencies:
       - netbird (>= 0.75.0)
       - libgtk-4-1 (>= 4.14)
@@ -120,11 +115,6 @@ nfpms:
         dst: /usr/share/applications/org.wails.netbird.desktop
       - src: client/ui/build/appicon.png
         dst: /usr/share/pixmaps/netbird.png
-      # Names the polkit action for the elevation prompt the app raises when an
-      # unprivileged user changes a privileged setting; without it the dialog
-      # shows a raw command line.
-      - src: client/ui/build/linux/polkit/io.netbird.settings.policy
-        dst: /usr/share/polkit-1/actions/io.netbird.settings.policy
     dependencies:
       - netbird >= 0.75.0
       - (gtk4 >= 4.14 or libgtk-4-1 >= 4.14)

client/android/profile_state_test.go

@@ -16,17 +16,17 @@ func TestProfileAccountPathFor(t *testing.T) {
 		{
 			name:       "default profile",
 			configPath: "/data/data/io.netbird.client/files/netbird.cfg",
-			want:       filepath.FromSlash("/data/data/io.netbird.client/files/netbird.account.json"),
+			want:       "/data/data/io.netbird.client/files/netbird.account.json",
 		},
 		{
 			name:       "id profile",
 			configPath: "/data/data/io.netbird.client/files/profiles/4c5f5c8198c3989cffb5b5394f5a7ae0.json",
-			want:       filepath.FromSlash("/data/data/io.netbird.client/files/profiles/4c5f5c8198c3989cffb5b5394f5a7ae0.account.json"),
+			want:       "/data/data/io.netbird.client/files/profiles/4c5f5c8198c3989cffb5b5394f5a7ae0.account.json",
 		},
 		{
 			name:       "legacy name-keyed profile is handled the same way",
 			configPath: "/data/data/io.netbird.client/files/profiles/work.json",
-			want:       filepath.FromSlash("/data/data/io.netbird.client/files/profiles/work.account.json"),
+			want:       "/data/data/io.netbird.client/files/profiles/work.account.json",
 		},
 		{
 			name:       "empty path is rejected",

client/cmd/agentnetwork.go

@@ -0,0 +1,336 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/encoding/protojson"
+
+	"github.com/netbirdio/netbird/client/proto"
+)
+
+// agentNetworkAuthToken is the placeholder credential exported for
+// AI-tool CLIs: the Agent Network proxy authenticates callers by tunnel
+// peer and injects the real upstream credentials itself, so the
+// client-side token only needs to satisfy the tool's non-empty check.
+const agentNetworkAuthToken = "netbird"
+
+var (
+	agentNetworkProviderFlag string
+	agentNetworkModelFlag    string
+	agentNetworkJSONFlag     bool
+)
+
+var agentNetworkCmd = &cobra.Command{
+	Use:   "agent-network",
+	Short: "Show the Agent Network setup available to this peer",
+	Long: `Commands to inspect the Agent Network (AI provider proxy) setup this peer's groups authorize:
+the proxy endpoint, the reachable providers, and the allowed models.`,
+}
+
+var agentNetworkLsCmd = &cobra.Command{
+	Use:     "ls",
+	Aliases: []string{"list"},
+	Short:   "List the Agent Network endpoint, providers, and allowed models",
+	Example: "  netbird agent-network ls",
+	RunE:    agentNetworkLs,
+}
+
+var agentNetworkEnvCmd = &cobra.Command{
+	Use:   "env",
+	Short: "Print shell export lines that point AI tools at the Agent Network",
+	Long: `Print POSIX shell export lines that configure AI tools to use the Agent Network proxy.
+The variables depend on the provider's API shape — Anthropic API, AWS Bedrock, Google Vertex AI,
+and OpenAI-compatible providers each get the environment their tools expect (for Claude Code,
+following its LLM-gateway configuration). Apply them to the current shell with:
+
+  eval "$(netbird agent-network env)"
+
+When several providers are authorized, pass --provider to pick one; when several models are
+allowed, pass --model to pin one — nothing is ever guessed.`,
+	Example: "  eval \"$(netbird agent-network env)\"\n  eval \"$(netbird agent-network env --provider 'Bedrock prod' --model anthropic.claude-sonnet-4-5)\"",
+	RunE:    agentNetworkEnv,
+}
+
+func init() {
+	agentNetworkLsCmd.PersistentFlags().BoolVar(&agentNetworkJSONFlag, "json", false, "output the setup as JSON")
+	agentNetworkEnvCmd.PersistentFlags().StringVar(&agentNetworkProviderFlag, "provider", "", "provider to configure, by name or catalog id (required when several are authorized)")
+	agentNetworkEnvCmd.PersistentFlags().StringVar(&agentNetworkModelFlag, "model", "", "model to export (required when several models are allowed)")
+}
+
+// fetchAgentNetworkSetup asks the daemon for the caller-scoped Agent
+// Network setup. The daemon relays the request to management over its
+// existing peer connection, so no elevated permissions are needed.
+func fetchAgentNetworkSetup(cmd *cobra.Command) (*proto.GetAgentNetworkSetupResponse, error) {
+	conn, err := getClient(cmd)
+	if err != nil {
+		return nil, err
+	}
+	defer conn.Close()
+
+	client := proto.NewDaemonServiceClient(conn)
+	setup, err := client.GetAgentNetworkSetup(cmd.Context(), &proto.GetAgentNetworkSetupRequest{})
+	if err != nil {
+		if s, ok := status.FromError(err); ok && s.Code() == codes.Unimplemented {
+			return nil, fmt.Errorf("the running daemon does not support agent-network commands — update the NetBird daemon and restart the service")
+		}
+		return nil, fmt.Errorf("get agent network setup: %v", status.Convert(err).Message())
+	}
+	return setup, nil
+}
+
+func agentNetworkLs(cmd *cobra.Command, _ []string) error {
+	setup, err := fetchAgentNetworkSetup(cmd)
+	if err != nil {
+		return err
+	}
+
+	if agentNetworkJSONFlag {
+		out, err := protojson.MarshalOptions{Multiline: true, Indent: "  "}.Marshal(setup)
+		if err != nil {
+			return fmt.Errorf("marshal setup: %v", err)
+		}
+		cmd.Println(string(out))
+		return nil
+	}
+
+	if !setup.Configured {
+		cmd.Println("Agent Network is not available for this peer. Ask your administrator.")
+		return nil
+	}
+
+	cmd.Printf("Agent Network endpoint: %s\n", setup.Endpoint)
+	cmd.Println("(reachable while connected to NetBird)")
+	for _, p := range setup.Providers {
+		cmd.Println()
+		cmd.Printf("%s (%s)\n", sanitizeOutput(p.Name), sanitizeOutput(providerFlavorLabel(p)))
+		switch {
+		case p.AllModelsAllowed && len(p.Models) == 0:
+			cmd.Println("  All models allowed")
+		case p.AllModelsAllowed:
+			cmd.Println("  All models allowed, including:")
+			printModels(cmd, p.Models)
+		default:
+			cmd.Println("  Allowed models:")
+			printModels(cmd, p.Models)
+		}
+	}
+	cmd.Println()
+	cmd.Println("To configure an AI tool in the current shell: eval \"$(netbird agent-network env)\"")
+	return nil
+}
+
+func printModels(cmd *cobra.Command, models []string) {
+	if len(models) == 0 {
+		cmd.Println("    (none)")
+		return
+	}
+	for _, m := range models {
+		cmd.Printf("    %s\n", sanitizeOutput(m))
+	}
+}
+
+func providerFlavorLabel(p *proto.AgentNetworkProvider) string {
+	if p.ApiFlavor == "" {
+		return p.CatalogId
+	}
+	return fmt.Sprintf("%s · %s-flavor API", p.CatalogId, p.ApiFlavor)
+}
+
+func agentNetworkEnv(cmd *cobra.Command, _ []string) error {
+	setup, err := fetchAgentNetworkSetup(cmd)
+	if err != nil {
+		return err
+	}
+
+	if !setup.Configured {
+		// An answer, not an error: print nothing eval-able and say why on
+		// stderr so `eval "$(...)"` stays a harmless no-op.
+		cmd.PrintErrln("Agent Network is not available for this peer. Ask your administrator.")
+		return nil
+	}
+
+	lines, err := buildAgentNetworkEnv(setup, agentNetworkProviderFlag, agentNetworkModelFlag)
+	if err != nil {
+		return err
+	}
+	for _, line := range lines {
+		cmd.Println(line)
+	}
+	return nil
+}
+
+// buildAgentNetworkEnv renders the export lines for one selected
+// provider. Nothing is guessed: an ambiguous provider or model choice
+// comes back as comment lines instead of exports, and an invalid
+// --provider/--model is an error.
+func buildAgentNetworkEnv(setup *proto.GetAgentNetworkSetupResponse, providerFlag, modelFlag string) ([]string, error) {
+	provider, choiceLines, err := selectAgentNetworkProvider(setup.Providers, providerFlag)
+	if err != nil {
+		return nil, err
+	}
+	if provider == nil {
+		return choiceLines, nil
+	}
+
+	model, modelNotes, err := resolveAgentNetworkModel(provider, modelFlag)
+	if err != nil {
+		return nil, err
+	}
+
+	var lines []string
+	switch {
+	case provider.CatalogId == "bedrock_api":
+		// Claude Code's Bedrock-format gateway configuration: the proxy
+		// routes native Bedrock paths and injects the AWS credentials, so
+		// client-side signing is skipped.
+		lines = append(lines,
+			exportLine("CLAUDE_CODE_USE_BEDROCK", "1"),
+			exportLine("ANTHROPIC_BEDROCK_BASE_URL", setup.Endpoint),
+			exportLine("CLAUDE_CODE_SKIP_BEDROCK_AUTH", "1"),
+		)
+		if model != "" {
+			lines = append(lines, exportLine("ANTHROPIC_MODEL", model))
+		}
+	case provider.CatalogId == "vertex_ai_api":
+		// Claude Code's Vertex-format gateway configuration. Vertex
+		// requests carry the GCP project and region in the URL path, which
+		// the proxy forwards to the upstream — those two values belong to
+		// the operator's GCP setup and must come from the administrator.
+		lines = append(lines,
+			exportLine("CLAUDE_CODE_USE_VERTEX", "1"),
+			exportLine("ANTHROPIC_VERTEX_BASE_URL", setup.Endpoint),
+			exportLine("CLAUDE_CODE_SKIP_VERTEX_AUTH", "1"),
+		)
+		if model != "" {
+			lines = append(lines, exportLine("ANTHROPIC_MODEL", model))
+		}
+		lines = append(lines,
+			comment("Vertex requests carry your operator's GCP project and region in the URL."),
+			comment("Ask your administrator for the values, then export:"),
+			comment("  export ANTHROPIC_VERTEX_PROJECT_ID=<project>"),
+			comment("  export CLOUD_ML_REGION=<region>"),
+		)
+	case provider.ApiFlavor == "anthropic":
+		lines = append(lines,
+			exportLine("ANTHROPIC_BASE_URL", setup.Endpoint),
+			exportLine("ANTHROPIC_AUTH_TOKEN", agentNetworkAuthToken),
+		)
+		if model != "" {
+			lines = append(lines, exportLine("ANTHROPIC_MODEL", model))
+		}
+	case provider.ApiFlavor == "openai":
+		lines = append(lines,
+			exportLine("OPENAI_BASE_URL", setup.Endpoint),
+			exportLine("OPENAI_API_KEY", agentNetworkAuthToken),
+		)
+		if model != "" {
+			lines = append(lines, comment(fmt.Sprintf("Configure your tool to use model %s.", model)))
+		}
+	default:
+		lines = append(lines,
+			comment(fmt.Sprintf("Provider %s (%s) is dispatched by URL path; no standard environment", provider.Name, provider.CatalogId)),
+			comment("variables apply. Point your tool at the endpoint below (auth token: netbird):"),
+			comment("  "+setup.Endpoint),
+		)
+	}
+
+	for _, note := range modelNotes {
+		lines = append(lines, comment(note))
+	}
+	return lines, nil
+}
+
+// selectAgentNetworkProvider picks the provider to configure. An
+// explicit --provider matches the operator label or catalog id
+// (case-insensitive); with no flag a single authorized provider is
+// used, and several come back as comment lines asking for the flag.
+func selectAgentNetworkProvider(providers []*proto.AgentNetworkProvider, providerFlag string) (*proto.AgentNetworkProvider, []string, error) {
+	if providerFlag != "" {
+		wanted := strings.ToLower(strings.TrimSpace(providerFlag))
+		for _, p := range providers {
+			if strings.ToLower(strings.TrimSpace(p.Name)) == wanted || strings.ToLower(p.CatalogId) == wanted {
+				return p, nil, nil
+			}
+		}
+		names := make([]string, 0, len(providers))
+		for _, p := range providers {
+			names = append(names, fmt.Sprintf("%s (%s)", p.Name, p.CatalogId))
+		}
+		return nil, nil, fmt.Errorf("provider %q is not authorized for this peer — available: %s", providerFlag, strings.Join(names, ", "))
+	}
+
+	if len(providers) == 1 {
+		return providers[0], nil, nil
+	}
+
+	lines := []string{comment("Multiple providers are authorized — none configured. Re-run with --provider to pick one:")}
+	for _, p := range providers {
+		lines = append(lines, comment(fmt.Sprintf("  netbird agent-network env --provider %q   (%s)", p.Name, providerFlavorLabel(p))))
+	}
+	return nil, lines, nil
+}
+
+// resolveAgentNetworkModel picks the model for the selected provider. A
+// model is never guessed: --model wins (validated against the allowed
+// set), a single allowed model is used, and anything ambiguous is
+// returned as note lines instead.
+func resolveAgentNetworkModel(provider *proto.AgentNetworkProvider, modelFlag string) (string, []string, error) {
+	if modelFlag != "" {
+		if provider.AllModelsAllowed {
+			return modelFlag, nil, nil
+		}
+		wanted := strings.ToLower(strings.TrimSpace(modelFlag))
+		for _, m := range provider.Models {
+			if strings.ToLower(strings.TrimSpace(m)) == wanted {
+				return modelFlag, nil, nil
+			}
+		}
+		return "", nil, fmt.Errorf("model %q is not allowed on provider %s — run 'netbird agent-network ls' to see the allowed models", modelFlag, provider.Name)
+	}
+
+	if len(provider.Models) == 1 && !provider.AllModelsAllowed {
+		return provider.Models[0], nil, nil
+	}
+	if len(provider.Models) == 0 && provider.AllModelsAllowed {
+		return "", []string{"Any model is allowed; pass --model to pin one."}, nil
+	}
+
+	notes := []string{"Multiple models are allowed — none exported. Re-run with --model to pin one:"}
+	for _, m := range provider.Models {
+		notes = append(notes, "  "+m)
+	}
+	if provider.AllModelsAllowed {
+		notes = append(notes, "  (any other model the provider serves)")
+	}
+	return "", notes, nil
+}
+
+func exportLine(name, value string) string {
+	return fmt.Sprintf("export %s=%s", name, shellQuote(value))
+}
+
+func comment(text string) string {
+	return "# " + sanitizeOutput(text)
+}
+
+// shellQuote single-quotes a value for safe use in an eval'd export
+// line, escaping embedded single quotes.
+func shellQuote(v string) string {
+	return "'" + strings.ReplaceAll(v, "'", `'\''`) + "'"
+}
+
+// sanitizeOutput strips control characters (including newlines) from
+// server-supplied strings so operator-typed values can't break the
+// line-oriented output or smuggle lines past a `# ` comment prefix.
+func sanitizeOutput(v string) string {
+	return strings.Map(func(r rune) rune {
+		if r < 0x20 || r == 0x7f {
+			return -1
+		}
+		return r
+	}, v)
+}

client/cmd/agentnetwork_test.go

@@ -0,0 +1,165 @@
+package cmd
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/netbirdio/netbird/client/proto"
+)
+
+func anTestSetup(providers ...*proto.AgentNetworkProvider) *proto.GetAgentNetworkSetupResponse {
+	return &proto.GetAgentNetworkSetupResponse{
+		Configured: true,
+		Endpoint:   "https://calm-otter.proxy.example.com",
+		Providers:  providers,
+	}
+}
+
+func TestBuildAgentNetworkEnv_AnthropicSingleModel(t *testing.T) {
+	setup := anTestSetup(&proto.AgentNetworkProvider{
+		Name: "Anthropic prod", CatalogId: "anthropic_api", ApiFlavor: "anthropic",
+		Models: []string{"claude-sonnet-4-5"},
+	})
+
+	lines, err := buildAgentNetworkEnv(setup, "", "")
+	require.NoError(t, err)
+	assert.Equal(t, []string{
+		"export ANTHROPIC_BASE_URL='https://calm-otter.proxy.example.com'",
+		"export ANTHROPIC_AUTH_TOKEN='netbird'",
+		"export ANTHROPIC_MODEL='claude-sonnet-4-5'",
+	}, lines)
+}
+
+func TestBuildAgentNetworkEnv_MultipleModelsBecomeComments(t *testing.T) {
+	setup := anTestSetup(&proto.AgentNetworkProvider{
+		Name: "Anthropic prod", CatalogId: "anthropic_api", ApiFlavor: "anthropic",
+		Models: []string{"claude-sonnet-4-5", "claude-haiku-4-5"},
+	})
+
+	lines, err := buildAgentNetworkEnv(setup, "", "")
+	require.NoError(t, err)
+	assert.Contains(t, lines, "export ANTHROPIC_BASE_URL='https://calm-otter.proxy.example.com'")
+	assert.NotContains(t, strings.Join(lines, "\n"), "ANTHROPIC_MODEL=", "no model is ever guessed")
+	assert.Contains(t, strings.Join(lines, "\n"), "# Multiple models are allowed")
+}
+
+func TestBuildAgentNetworkEnv_ModelFlagValidated(t *testing.T) {
+	setup := anTestSetup(&proto.AgentNetworkProvider{
+		Name: "Anthropic prod", CatalogId: "anthropic_api", ApiFlavor: "anthropic",
+		Models: []string{"claude-sonnet-4-5", "claude-haiku-4-5"},
+	})
+
+	lines, err := buildAgentNetworkEnv(setup, "", "Claude-Haiku-4-5")
+	require.NoError(t, err, "model match is case-insensitive")
+	assert.Contains(t, lines, "export ANTHROPIC_MODEL='Claude-Haiku-4-5'")
+
+	_, err = buildAgentNetworkEnv(setup, "", "gpt-4o")
+	require.Error(t, err, "a model outside the allowlist is rejected")
+}
+
+func TestBuildAgentNetworkEnv_BedrockFlavor(t *testing.T) {
+	setup := anTestSetup(&proto.AgentNetworkProvider{
+		Name: "Bedrock prod", CatalogId: "bedrock_api", ApiFlavor: "",
+		Models: []string{"anthropic.claude-sonnet-4-5"},
+	})
+
+	lines, err := buildAgentNetworkEnv(setup, "", "")
+	require.NoError(t, err)
+	assert.Equal(t, []string{
+		"export CLAUDE_CODE_USE_BEDROCK='1'",
+		"export ANTHROPIC_BEDROCK_BASE_URL='https://calm-otter.proxy.example.com'",
+		"export CLAUDE_CODE_SKIP_BEDROCK_AUTH='1'",
+		"export ANTHROPIC_MODEL='anthropic.claude-sonnet-4-5'",
+	}, lines)
+}
+
+func TestBuildAgentNetworkEnv_VertexFlavorNotesProjectAndRegion(t *testing.T) {
+	setup := anTestSetup(&proto.AgentNetworkProvider{
+		Name: "Vertex prod", CatalogId: "vertex_ai_api", ApiFlavor: "",
+		Models: []string{"claude-sonnet-4-5"},
+	})
+
+	lines, err := buildAgentNetworkEnv(setup, "", "")
+	require.NoError(t, err)
+	joined := strings.Join(lines, "\n")
+	assert.Contains(t, lines, "export CLAUDE_CODE_USE_VERTEX='1'")
+	assert.Contains(t, lines, "export ANTHROPIC_VERTEX_BASE_URL='https://calm-otter.proxy.example.com'")
+	assert.Contains(t, lines, "export CLAUDE_CODE_SKIP_VERTEX_AUTH='1'")
+	assert.Contains(t, lines, "export ANTHROPIC_MODEL='claude-sonnet-4-5'")
+	assert.Contains(t, joined, "ANTHROPIC_VERTEX_PROJECT_ID", "project id must be called out as admin-supplied")
+	assert.Contains(t, joined, "CLOUD_ML_REGION", "region must be called out as admin-supplied")
+}
+
+func TestBuildAgentNetworkEnv_OpenAIFlavor(t *testing.T) {
+	setup := anTestSetup(&proto.AgentNetworkProvider{
+		Name: "OpenAI prod", CatalogId: "openai_api", ApiFlavor: "openai",
+		Models: []string{"gpt-5.4"},
+	})
+
+	lines, err := buildAgentNetworkEnv(setup, "", "")
+	require.NoError(t, err)
+	assert.Contains(t, lines, "export OPENAI_BASE_URL='https://calm-otter.proxy.example.com'")
+	assert.Contains(t, lines, "export OPENAI_API_KEY='netbird'")
+	assert.NotContains(t, strings.Join(lines, "\n"), "ANTHROPIC_", "openai flavor must not emit anthropic variables")
+}
+
+func TestBuildAgentNetworkEnv_MultipleProvidersRequireFlag(t *testing.T) {
+	anthropic := &proto.AgentNetworkProvider{Name: "Anthropic prod", CatalogId: "anthropic_api", ApiFlavor: "anthropic", Models: []string{"claude-sonnet-4-5"}}
+	bedrock := &proto.AgentNetworkProvider{Name: "Bedrock prod", CatalogId: "bedrock_api", Models: []string{"anthropic.claude-sonnet-4-5"}}
+	setup := anTestSetup(anthropic, bedrock)
+
+	lines, err := buildAgentNetworkEnv(setup, "", "")
+	require.NoError(t, err)
+	joined := strings.Join(lines, "\n")
+	assert.NotContains(t, joined, "export ", "ambiguous provider choice must export nothing")
+	assert.Contains(t, joined, "--provider")
+	assert.Contains(t, joined, "Bedrock prod")
+
+	// Selection by operator label, case-insensitive.
+	lines, err = buildAgentNetworkEnv(setup, "bedrock prod", "")
+	require.NoError(t, err)
+	assert.Contains(t, lines, "export CLAUDE_CODE_USE_BEDROCK='1'")
+
+	// Selection by catalog id.
+	lines, err = buildAgentNetworkEnv(setup, "anthropic_api", "")
+	require.NoError(t, err)
+	assert.Contains(t, lines, "export ANTHROPIC_AUTH_TOKEN='netbird'")
+
+	// Unknown provider is an error naming the available ones.
+	_, err = buildAgentNetworkEnv(setup, "vertex", "")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "Anthropic prod")
+}
+
+func TestBuildAgentNetworkEnv_AllModelsAllowed(t *testing.T) {
+	setup := anTestSetup(&proto.AgentNetworkProvider{
+		Name: "Anthropic prod", CatalogId: "anthropic_api", ApiFlavor: "anthropic",
+		AllModelsAllowed: true, Models: []string{"claude-sonnet-4-5"},
+	})
+
+	// A courtesy-listed single model is still ambiguous when everything is allowed.
+	lines, err := buildAgentNetworkEnv(setup, "", "")
+	require.NoError(t, err)
+	assert.NotContains(t, strings.Join(lines, "\n"), "ANTHROPIC_MODEL=")
+
+	// --model passes without allowlist validation.
+	lines, err = buildAgentNetworkEnv(setup, "", "claude-opus-4-8")
+	require.NoError(t, err)
+	assert.Contains(t, lines, "export ANTHROPIC_MODEL='claude-opus-4-8'")
+}
+
+func TestBuildAgentNetworkEnv_UnknownFlavorFallsBackToComments(t *testing.T) {
+	setup := anTestSetup(&proto.AgentNetworkProvider{
+		Name: "Kimi", CatalogId: "kimi_api", ApiFlavor: "",
+		Models: []string{"kimi-k3"},
+	})
+
+	lines, err := buildAgentNetworkEnv(setup, "", "")
+	require.NoError(t, err)
+	joined := strings.Join(lines, "\n")
+	assert.NotContains(t, joined, "export ", "unknown API shape must not guess variables")
+	assert.Contains(t, joined, "https://calm-otter.proxy.example.com")
+}

client/cmd/root.go

@@ -171,6 +171,9 @@ func init() {
 	rootCmd.AddCommand(debugCmd)
 	rootCmd.AddCommand(profileCmd)
 	rootCmd.AddCommand(exposeCmd)
+	rootCmd.AddCommand(agentNetworkCmd)
+	agentNetworkCmd.AddCommand(agentNetworkLsCmd)
+	agentNetworkCmd.AddCommand(agentNetworkEnvCmd)
 
 	networksCMD.AddCommand(routesListCmd)
 	networksCMD.AddCommand(routesSelectCmd, routesDeselectCmd)

client/internal/daemonaddr/identity.go

@@ -1,14 +0,0 @@
-package daemonaddr
-
-import "strings"
-
-// CarriesIdentity reports whether the control channel at addr conveys the
-// connecting process's identity to the daemon. A Unix socket carries peer
-// credentials and a named pipe carries the client's token; loopback TCP carries
-// neither, so on such an address the daemon cannot authorize a privileged
-// operation for anybody. A client uses this to tell whether becoming privileged
-// would get it anywhere: on an identity-less address it would not, and the only
-// way forward is to move the daemon onto one that carries identity.
-func CarriesIdentity(addr string) bool {
-	return strings.HasPrefix(addr, "unix://") || strings.HasPrefix(addr, pipeScheme)
-}

client/internal/daemonaddr/identity_test.go

@@ -1,29 +0,0 @@
-package daemonaddr
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestCarriesIdentity(t *testing.T) {
-	tests := []struct {
-		addr string
-		want bool
-	}{
-		{"unix:///var/run/netbird.sock", true},
-		{"unix:///var/run/netbird/default.sock", true},
-		{"npipe://netbird", true},
-		{`npipe://\\.\pipe\ProtectedPrefix\Administrators\netbird`, true},
-		{"tcp://127.0.0.1:41731", false},
-		{"tcp://localhost:41731", false},
-		{"", false},
-		{"/var/run/netbird.sock", false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.addr, func(t *testing.T) {
-			assert.Equal(t, tt.want, CarriesIdentity(tt.addr), "address %q", tt.addr)
-		})
-	}
-}

client/internal/elevate/elevate.go

@@ -1,74 +0,0 @@
-// Package elevate re-runs this very executable under the operating system's own
-// privilege-elevation mechanism and waits for it to finish.
-//
-// It exists so that a change the daemon restricts to root/administrator can be
-// authorized from the GUI, by the user, at the moment they ask for it: Windows
-// shows the UAC consent dialog, macOS the system authentication dialog, and
-// Linux/FreeBSD the session's polkit agent. The credentials, where any are
-// asked for, are collected by the operating system and never pass through
-// NetBird.
-//
-// What the elevated process then does is the caller's business: it is the same
-// binary, in a one-shot mode, and it is authorized by the daemon exactly like
-// any other privileged caller, from the identity the kernel reports on the
-// control channel. Nothing here grants privilege, and the daemon gains no new
-// way to be talked into something: elevation only changes who is calling it.
-package elevate
-
-import (
-	"context"
-	"errors"
-
-	log "github.com/sirupsen/logrus"
-)
-
-// AppliedMarker is what the elevated process prints on standard output once it has
-// done what it was run for.
-//
-// macOS's AuthorizationExecuteWithPrivileges reports no exit status and does not
-// say which process it started, so there this line is the only evidence that the
-// change was applied. The other platforms have an exit code and ignore it.
-const AppliedMarker = "netbird-elevated: applied"
-
-var (
-	// ErrDeclined reports that the user dismissed the prompt or did not
-	// authenticate. Nothing happened and nothing is wrong: a caller undoes its
-	// optimistic update and stays quiet.
-	ErrDeclined = errors.New("authorization declined")
-
-	// ErrUnavailable reports that this host has no elevation mechanism we can
-	// drive: no polkit on a Unix desktop, or an executable we decline to run as
-	// root. A caller falls back to telling the user which command to run.
-	ErrUnavailable = errors.New("no privilege elevation mechanism available")
-)
-
-// Run runs this executable with args under the platform's elevation mechanism
-// and waits for it to exit. A non-zero exit is returned as an error, so the
-// caller can treat a completed Run as the operation having succeeded.
-//
-// The args are the caller's own command line, so they cross no privilege
-// boundary: only a user who has just authenticated as an administrator can get
-// them run at all.
-func Run(ctx context.Context, args ...string) error {
-	self, err := trustedSelf()
-	if err != nil {
-		return err
-	}
-	return run(ctx, self, args)
-}
-
-// Available reports whether Run has a mechanism to use on this host, so a caller
-// can offer the prompt only when there is one and otherwise fall back to
-// guidance the user can act on. It answers from what is installed, not from what
-// the user is allowed to do: an administrator's password may still be required
-// and may still not be given, which is ErrDeclined from Run.
-func Available() bool {
-	if _, err := trustedSelf(); err != nil {
-		// Worth a line: this is also what a build run from a group-writable
-		// directory hits, and there is nothing in the UI to say why the offer is
-		// missing.
-		log.Debugf("not offering privilege elevation: %v", err)
-		return false
-	}
-	return mechanismAvailable()
-}

client/internal/elevate/output.go

@@ -1,19 +0,0 @@
-package elevate
-
-import "strings"
-
-// noOutput stands in for a process that said nothing, so that a report of what it
-// said still reads as a sentence.
-const noOutput = "no output"
-
-// firstLine trims captured output to something that reads in one line.
-func firstLine(s string) string {
-	s = strings.TrimSpace(s)
-	if s == "" {
-		return noOutput
-	}
-	if i := strings.IndexByte(s, '\n'); i >= 0 {
-		return s[:i]
-	}
-	return s
-}

client/internal/elevate/output_test.go

@@ -1,21 +0,0 @@
-package elevate
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestFirstLine(t *testing.T) {
-	tests := []struct{ in, want string }{
-		{in: "", want: noOutput},
-		{in: "  \n ", want: noOutput},
-		{in: "one line", want: "one line"},
-		{in: "first\nsecond", want: "first"},
-		{in: "\nsecond\n", want: "second"},
-	}
-
-	for _, tt := range tests {
-		assert.Equal(t, tt.want, firstLine(tt.in), "input %q", tt.in)
-	}
-}

client/internal/elevate/run_darwin.go

@@ -1,359 +0,0 @@
-package elevate
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"runtime"
-	"strings"
-	"sync"
-	"syscall"
-	"unsafe"
-
-	"github.com/ebitengine/purego"
-	log "github.com/sirupsen/logrus"
-)
-
-// Authorization Services, reached through purego rather than cgo so the released
-// binaries keep building with CGO_ENABLED=0.
-//
-// The prompt belongs to this process, which is what makes it carry the
-// application's name and our own explanation. Going through osascript instead puts
-// the very same trampoline behind a dialog attributed to osascript, and means
-// handing a shell a command line to re-parse.
-//
-// # On AuthorizationExecuteWithPrivileges
-//
-// It is deprecated, and Apple's guidance (Quinn, "BSD Privilege Escalation on
-// macOS", developer.apple.com/forums/thread/708765) is "while it still works, it's
-// been deprecated for many years. Do not use it in a widely distributed product."
-// It is used here anyway, knowingly, because the alternatives Apple offers are for
-// *obtaining* ongoing privileges — an installer package, SMAppService, SMJobBless —
-// and NetBird already has what they would install: a launchd daemon running as
-// root. What is missing is only a way for an unprivileged client to ask it to act.
-//
-// The way to that without a deprecated call is to authorize the client instead of
-// elevating one: the app takes the right with AuthorizationCreate, passes the
-// AuthorizationExternalForm to the daemon, and the daemon checks it with
-// AuthorizationCopyRights before acting — none of which is deprecated. It is the
-// better design and it is where this should end up. It also means the daemon
-// accepting an authorization over its control socket, which is a new way to be
-// asked for privileged work and wants reviewing as such, so it is deliberately not
-// bundled in with the rest of this.
-//
-// Until then, three things keep the deprecation from being a trap. Every symbol is
-// resolved with an error rather than a panic, so a macOS that has dropped this
-// function leaves the app offering the user a command instead of crashing on the
-// way to a prompt. A failure to run the tool is reported as ErrUnavailable, so the
-// fallback is the same one an agent-less Linux session gets. And the whole path
-// runs under guard, which turns a panic out of the FFI layer into that same
-// fallback.
-//
-// The trampoline passes on the environment it was given, so what it starts as root
-// must be an executable this user's peers cannot influence: that is what
-// trustedSelf refuses, and what signing the binary settles for the loader.
-
-const (
-	securityFramework = "/System/Library/Frameworks/Security.framework/Security"
-	libSystem         = "/usr/lib/libSystem.B.dylib"
-
-	// trampoline is what the framework hands the tool to. Present on every macOS,
-	// and worth confirming before offering a prompt rather than mid-prompt.
-	trampoline = "/usr/libexec/security_authtrampoline"
-)
-
-// rightExecute is the right an administrator holds, and what
-// AuthorizationExecuteWithPrivileges requires of us.
-const rightExecute = "system.privilege.admin"
-
-// promptKey is kAuthorizationEnvironmentPrompt, which puts a sentence of ours above
-// the system's in the dialog. It is about the change rather than the mechanism.
-const (
-	promptKey  = "prompt"
-	promptText = "NetBird needs to change a setting that grants SSH access to this computer."
-)
-
-// OSStatus values from SecBase.h that mean something to us; anything else is
-// reported as it comes.
-const (
-	errAuthorizationSuccess               = 0
-	errAuthorizationDenied                = -60005
-	errAuthorizationCanceled              = -60006
-	errAuthorizationInteractionNotAllowed = -60007
-	errAuthorizationToolExecuteFailure    = -60031
-	errAuthorizationToolEnvironmentError  = -60032
-)
-
-// AuthorizationFlags from Authorization.h.
-const (
-	flagDefaults           = 0
-	flagInteractionAllowed = 1 << 0
-	flagExtendRights       = 1 << 1
-	flagDestroyRights      = 1 << 3
-	flagPreAuthorize       = 1 << 4
-)
-
-// authorizationItem mirrors AuthorizationItem: a name, and a value the name gives
-// meaning to. 32 bytes on both amd64 and arm64.
-type authorizationItem struct {
-	name        *byte
-	valueLength uintptr
-	value       unsafe.Pointer
-	// flags is reserved by the API and always zero. Declared because the layout
-	// is the contract: without it the struct is 24 bytes where C reads 32.
-	flags uint32 //nolint:unused // part of the C layout
-}
-
-// authorizationItemSet mirrors AuthorizationItemSet, which serves as both an
-// AuthorizationRights and an AuthorizationEnvironment.
-type authorizationItemSet struct {
-	count uint32
-	items *authorizationItem
-}
-
-var (
-	authorizationCreate                func(rights, environment *authorizationItemSet, flags uint32, authorization *uintptr) int32
-	authorizationExecuteWithPrivileges func(authorization uintptr, pathToTool string, options uint32, arguments *uintptr, communicationsPipe *uintptr) int32
-	authorizationFree                  func(authorization uintptr, flags uint32) int32
-	fileno                             func(stream uintptr) int32
-	fclose                             func(stream uintptr) int32
-
-	loadOnce sync.Once
-	loadErr  error
-)
-
-// load resolves the functions once. A framework that cannot be opened, or a symbol
-// that is no longer there, leaves the host without a mechanism rather than taking
-// the process down with it: see the note on deprecation above.
-func load() error {
-	loadOnce.Do(func() { loadErr = guard("loading Security.framework", resolve) })
-	return loadErr
-}
-
-// guard turns a panic out of the FFI layer into an error, so an API that has
-// changed under us costs the user a prompt rather than the window they were
-// clicking in. purego panics on a signature it cannot map, and this is the one
-// place in the client that calls a deprecated system function.
-//
-// It catches Go panics, which is what purego raises. A fault inside the framework
-// itself is not a panic and not recoverable; the layout the tests pin down is what
-// stands between us and that.
-func guard(what string, fn func() error) (err error) {
-	defer func() {
-		r := recover()
-		if r == nil {
-			return
-		}
-		log.Errorf("%s panicked: %v", what, r)
-		err = fmt.Errorf("%w: %s: %v", ErrUnavailable, what, r)
-	}()
-	return fn()
-}
-
-func resolve() error {
-	security, err := purego.Dlopen(securityFramework, purego.RTLD_LAZY|purego.RTLD_GLOBAL)
-	if err != nil {
-		return fmt.Errorf("open %s: %w", securityFramework, err)
-	}
-	system, err := purego.Dlopen(libSystem, purego.RTLD_LAZY|purego.RTLD_GLOBAL)
-	if err != nil {
-		return fmt.Errorf("open %s: %w", libSystem, err)
-	}
-
-	// purego.RegisterLibFunc panics on a symbol it cannot find, which is not how a
-	// deprecated function's disappearance should reach the user.
-	for _, fn := range []struct {
-		ptr    any
-		handle uintptr
-		name   string
-	}{
-		{&authorizationCreate, security, "AuthorizationCreate"},
-		{&authorizationExecuteWithPrivileges, security, "AuthorizationExecuteWithPrivileges"},
-		{&authorizationFree, security, "AuthorizationFree"},
-		{&fileno, system, "fileno"},
-		{&fclose, system, "fclose"},
-	} {
-		symbol, err := purego.Dlsym(fn.handle, fn.name)
-		if err != nil {
-			return fmt.Errorf("resolve %s: %w", fn.name, err)
-		}
-		if symbol == 0 {
-			return fmt.Errorf("resolve %s: not present on this system", fn.name)
-		}
-		purego.RegisterFunc(fn.ptr, symbol)
-	}
-	return nil
-}
-
-// run asks the system to run self as root: first for the right, which is what puts
-// up the authentication dialog and collects the password or takes the Touch ID,
-// then for the tool. The credentials go to the system's authorization trampoline
-// and never to us.
-//
-// The context bounds only our own waiting; the dialog belongs to the system and
-// closes when the user answers it.
-func run(ctx context.Context, self string, args []string) error {
-	if err := load(); err != nil {
-		return fmt.Errorf("%w: %v", ErrUnavailable, err)
-	}
-
-	return guard("asking for privileges", func() error {
-		authorization, err := authorize()
-		if err != nil {
-			return err
-		}
-		defer authorizationFree(authorization, flagDestroyRights)
-
-		return execute(ctx, authorization, self, args)
-	})
-}
-
-func mechanismAvailable() bool {
-	if err := load(); err != nil {
-		return false
-	}
-	info, err := os.Stat(trampoline)
-	return err == nil && !info.IsDir()
-}
-
-// authorize obtains the right, prompting for it. A dismissed dialog comes back as
-// errAuthorizationCanceled and a password given up on as errAuthorizationDenied;
-// both are the user's answer rather than a failure.
-func authorize() (uintptr, error) {
-	var pinner runtime.Pinner
-	defer pinner.Unpin()
-
-	rights := itemSet(&pinner, authorizationItem{name: cString(&pinner, rightExecute)})
-	environment := itemSet(&pinner, promptItem(&pinner))
-
-	var authorization uintptr
-	status := authorizationCreate(rights, environment,
-		flagDefaults|flagInteractionAllowed|flagPreAuthorize|flagExtendRights, &authorization)
-
-	switch status {
-	case errAuthorizationSuccess:
-		return authorization, nil
-	case errAuthorizationCanceled, errAuthorizationDenied:
-		return 0, ErrDeclined
-	case errAuthorizationInteractionNotAllowed:
-		// Nowhere to put a dialog, so there is nobody to ask: a launch daemon, or
-		// a session with no window server.
-		return 0, fmt.Errorf("%w: this session cannot show an authorization prompt", ErrUnavailable)
-	default:
-		return 0, fmt.Errorf("request %s: OSStatus %d", rightExecute, status)
-	}
-}
-
-// execute runs the tool with the right in hand and waits for it by reading the pipe
-// it is given until the tool closes it.
-//
-// AuthorizationExecuteWithPrivileges reports no exit status and does not say what
-// process it started, which is why the one-shot says so itself: what it prints is
-// the only evidence that the change was applied.
-func execute(ctx context.Context, authorization uintptr, self string, args []string) error {
-	var pinner runtime.Pinner
-	defer pinner.Unpin()
-
-	argv := make([]uintptr, 0, len(args)+1)
-	for _, arg := range args {
-		argv = append(argv, uintptr(unsafe.Pointer(cString(&pinner, arg))))
-	}
-	argv = append(argv, 0)
-	pinner.Pin(&argv[0])
-
-	var pipe uintptr
-	status := authorizationExecuteWithPrivileges(authorization, self, flagDefaults, &argv[0], &pipe)
-	switch status {
-	case errAuthorizationSuccess:
-	case errAuthorizationCanceled:
-		return ErrDeclined
-	case errAuthorizationToolExecuteFailure, errAuthorizationToolEnvironmentError:
-		// The right was granted and the tool still did not start. Nothing the user
-		// can do about it from here, so point them at the command instead.
-		return fmt.Errorf("%w: the system would not run %s elevated (OSStatus %d)", ErrUnavailable, self, status)
-	default:
-		return fmt.Errorf("run %s elevated: OSStatus %d", self, status)
-	}
-
-	out, err := readPipe(ctx, pipe)
-	if err != nil {
-		return err
-	}
-	return checkApplied(out)
-}
-
-// checkApplied reads the one-shot's report, which stands in for the exit status
-// there is no way to ask for here. A run that said nothing did not apply the
-// change, whatever else went on.
-func checkApplied(out string) error {
-	if !strings.Contains(out, AppliedMarker) {
-		return fmt.Errorf("elevated netbird did not report the change as applied: %s", firstLine(out))
-	}
-	return nil
-}
-
-// readPipe drains the tool's output, which ends when the tool exits and is
-// therefore also how we wait for it.
-func readPipe(ctx context.Context, pipe uintptr) (string, error) {
-	if pipe == 0 {
-		return "", nil
-	}
-	defer fclose(pipe)
-
-	fd := int(fileno(pipe))
-	if fd < 0 {
-		return "", nil
-	}
-
-	var out strings.Builder
-	buf := make([]byte, 4096)
-	for {
-		if err := ctx.Err(); err != nil {
-			return out.String(), err
-		}
-		n, err := syscall.Read(fd, buf)
-		if n > 0 {
-			out.Write(buf[:n])
-		}
-		switch {
-		case errors.Is(err, syscall.EINTR):
-			// A signal landed mid-read, which says nothing about the tool.
-			continue
-		case err != nil:
-			log.Debugf("read the elevated process's output: %v", err)
-			return out.String(), nil
-		case n <= 0:
-			// End of file: the tool closed the pipe, which is how it exiting
-			// reaches us.
-			return out.String(), nil
-		}
-	}
-}
-
-// itemSet builds an AuthorizationItemSet over items, pinned for the call.
-func itemSet(pinner *runtime.Pinner, items ...authorizationItem) *authorizationItemSet {
-	pinner.Pin(&items[0])
-	set := &authorizationItemSet{count: uint32(len(items)), items: &items[0]}
-	pinner.Pin(set)
-	return set
-}
-
-// promptItem is the environment entry carrying our sentence for the dialog.
-func promptItem(pinner *runtime.Pinner) authorizationItem {
-	value := []byte(promptText)
-	pinner.Pin(&value[0])
-	return authorizationItem{
-		name:        cString(pinner, promptKey),
-		valueLength: uintptr(len(value)),
-		value:       unsafe.Pointer(&value[0]),
-	}
-}
-
-// cString returns a NUL-terminated copy of s, pinned so the C side may hold it for
-// the duration of the call.
-func cString(pinner *runtime.Pinner, s string) *byte {
-	b := append([]byte(s), 0)
-	pinner.Pin(&b[0])
-	return &b[0]
-}

client/internal/elevate/run_darwin_test.go

@@ -1,111 +0,0 @@
-package elevate
-
-import (
-	"errors"
-	"runtime"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// The framework has to load and the symbols have to resolve, or nothing else here
-// means anything.
-func TestSecurityFrameworkLoads(t *testing.T) {
-	require.NoError(t, load(), "Security.framework must open")
-
-	for name, fn := range map[string]any{
-		"AuthorizationCreate":                authorizationCreate,
-		"AuthorizationExecuteWithPrivileges": authorizationExecuteWithPrivileges,
-		"AuthorizationFree":                  authorizationFree,
-		"fileno":                             fileno,
-		"fclose":                             fclose,
-	} {
-		assert.NotNil(t, fn, "%s must resolve", name)
-	}
-}
-
-// A request with no interaction allowed exercises the whole call — the rights and
-// environment structs, and the OSStatus that comes back — without a dialog anybody
-// has to answer. What the system decides is its business; that it decides at all is
-// what this asserts.
-func TestAuthorizationCreateWithoutInteraction(t *testing.T) {
-	if err := load(); err != nil {
-		t.Skipf("Security.framework did not open: %v", err)
-	}
-
-	var pinner runtime.Pinner
-	defer pinner.Unpin()
-
-	rights := itemSet(&pinner, authorizationItem{name: cString(&pinner, rightExecute)})
-	environment := itemSet(&pinner, promptItem(&pinner))
-	require.EqualValues(t, 1, rights.count, "the rights struct layout must match the C one")
-
-	var authorization uintptr
-	status := authorizationCreate(rights, environment, flagDefaults|flagExtendRights, &authorization)
-
-	switch status {
-	case errAuthorizationSuccess:
-		// Credentials were already cached for this session.
-		authorizationFree(authorization, flagDestroyRights)
-	case errAuthorizationDenied, errAuthorizationInteractionNotAllowed:
-		// The expected answers when nobody may be asked.
-	default:
-		require.Failf(t, "unknown OSStatus", "AuthorizationCreate returned %d, want a status we recognise", status)
-	}
-}
-
-// Asking with a right nobody has must not be mistaken for a declined prompt: the
-// caller would report nothing at all.
-func TestAuthorizeUnknownRightIsNotDeclined(t *testing.T) {
-	if err := load(); err != nil {
-		t.Skipf("Security.framework did not open: %v", err)
-	}
-
-	var pinner runtime.Pinner
-	defer pinner.Unpin()
-
-	rights := itemSet(&pinner, authorizationItem{name: cString(&pinner, "io.netbird.right.that.does.not.exist")})
-
-	var authorization uintptr
-	status := authorizationCreate(rights, nil, flagDefaults|flagExtendRights, &authorization)
-	if status == errAuthorizationSuccess {
-		authorizationFree(authorization, flagDestroyRights)
-	}
-	assert.NotEqual(t, int32(errAuthorizationSuccess), status, "a right that does not exist must not be granted")
-}
-
-func TestMechanismAvailable(t *testing.T) {
-	assert.True(t, mechanismAvailable(), "the trampoline exists on every macOS")
-}
-
-// The one-shot's report is what stands in for an exit status here, so a run that
-// says nothing must not read as success.
-func TestCheckApplied(t *testing.T) {
-	require.NoError(t, checkApplied(AppliedMarker+"\n"), "the report the one-shot prints")
-	require.NoError(t, checkApplied("some warning\n"+AppliedMarker+"\n"), "the report after other output")
-
-	assert.Error(t, checkApplied(""), "a run that printed nothing did not apply the change")
-	assert.Error(t, checkApplied("dyld: library not loaded\n"), "output that is not the report")
-}
-
-// A panic out of the FFI layer has to reach the caller as "no mechanism", which is
-// the outcome that offers the user the command instead of taking the window down.
-func TestGuardTurnsAPanicIntoUnavailable(t *testing.T) {
-	err := guard("pretending to call something", func() error {
-		panic("purego: signature it cannot map")
-	})
-
-	require.ErrorIs(t, err, ErrUnavailable, "a panic must read as a missing mechanism")
-	assert.Contains(t, err.Error(), "pretending to call something", "what panicked")
-}
-
-// guard wraps every darwin path, so what a caller switches on has to survive it.
-func TestGuardPassesErrorsThrough(t *testing.T) {
-	sentinel := errors.New("the call itself failed")
-	assert.ErrorIs(t, guard("calling", func() error { return sentinel }), sentinel,
-		"the error it was given")
-	assert.ErrorIs(t, guard("calling", func() error { return ErrDeclined }), ErrDeclined,
-		"a declined prompt stays declined")
-	assert.NoError(t, guard("calling", func() error { return nil }), "a call that worked")
-}

client/internal/elevate/run_unix.go

@@ -1,117 +0,0 @@
-//go:build linux || freebsd
-
-package elevate
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"strings"
-)
-
-// pkexec exit codes that are about the authorization rather than about the program
-// we asked it to run. The manual page reserves both.
-const (
-	// exitDismissed is returned when the user dismissed the authentication
-	// dialog.
-	exitDismissed = 126
-	// exitNotAuthorized is returned when the authorization was not obtained. That
-	// covers the user saying no as well as pkexec having had nobody to ask: see
-	// noAgentMarkers.
-	exitNotAuthorized = 127
-)
-
-// exitNotAuthorized covers three different endings that only pkexec's own words
-// tell apart, so they are matched here. Read with LC_ALL=C so the words are the
-// ones written below.
-//
-// refusedMarker is a refusal: the user said no, gave up on the password, or holds
-// an account that may not elevate at all.
-const refusedMarker = "Not authorized"
-
-// noAgentMarkers say pkexec had no way to ask: no agent registered for the
-// session, and no controlling terminal for the textual agent it falls back to.
-var noAgentMarkers = []string{"authentication agent", "controlling terminal"}
-
-// run asks polkit to run self as root. pkexec hands the request to the session's
-// polkit agent, which is what prompts and what collects any password; we see only
-// its verdict.
-//
-// The environment is otherwise deliberately not passed through: pkexec clears it
-// bar a small allowlist, and the one-shot needs nothing from it.
-func run(ctx context.Context, self string, args []string) error {
-	pkexec, err := exec.LookPath("pkexec")
-	if err != nil {
-		return fmt.Errorf("%w: pkexec is not installed", ErrUnavailable)
-	}
-
-	cmd := exec.CommandContext(ctx, pkexec, append([]string{self}, args...)...)
-	// C locale so pkexec's own diagnostics are the ones noAgentMarkers knows.
-	cmd.Env = append(os.Environ(), "LC_ALL=C")
-	var stderr strings.Builder
-	cmd.Stderr = &stderr
-	// The one-shot reports itself on stdout for macOS's sake, where there is no
-	// exit status to read. Here there is one, so that line is noise.
-	cmd.Stdout = io.Discard
-
-	err = cmd.Run()
-	if err == nil {
-		return nil
-	}
-
-	var exitErr *exec.ExitError
-	if !errors.As(err, &exitErr) {
-		return fmt.Errorf("run pkexec: %w", err)
-	}
-
-	// Matched against everything pkexec said, reported as one line: a complaint
-	// that is not the first thing printed still has to be recognised, and reading
-	// it as a refusal would swallow it.
-	full := stderr.String()
-	out := firstLine(full)
-
-	switch exitErr.ExitCode() {
-	case exitDismissed:
-		return ErrDeclined
-	case exitNotAuthorized:
-		return notAuthorized(full, out)
-	default:
-		return fmt.Errorf("elevated netbird exited with %d: %s", exitErr.ExitCode(), out)
-	}
-}
-
-// notAuthorized sorts out the three endings pkexec reports as exitNotAuthorized.
-//
-// It also returns that code when the authorization succeeded and it then could
-// not run the program, so a refusal has to be recognised rather than assumed:
-// reading every one of these as "the user said no" would revert the control in
-// silence on a host where elevation is broken.
-func notAuthorized(full, out string) error {
-	switch {
-	case hasAny(full, noAgentMarkers):
-		return fmt.Errorf("%w: polkit had no way to ask: %s", ErrUnavailable, out)
-	case out == noOutput, strings.Contains(full, refusedMarker):
-		// The user said no, which needs no message; that an account barred from
-		// elevating altogether lands here too is why the reason is kept.
-		return fmt.Errorf("%w: %s", ErrDeclined, out)
-	default:
-		return fmt.Errorf("pkexec could not run elevated netbird: %s", out)
-	}
-}
-
-func hasAny(s string, markers []string) bool {
-	for _, marker := range markers {
-		if strings.Contains(s, marker) {
-			return true
-		}
-	}
-	return false
-}
-
-func mechanismAvailable() bool {
-	_, err := exec.LookPath("pkexec")
-	return err == nil
-}

client/internal/elevate/run_unix_test.go

@@ -1,110 +0,0 @@
-//go:build linux || freebsd
-
-package elevate
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// fakePkexec puts a pkexec on PATH that exits with the given code, so the
-// mapping from polkit's exit codes onto our errors can be exercised without a
-// polkit agent.
-func fakePkexec(t *testing.T, exitCode int, stderr string) {
-	t.Helper()
-
-	dir := t.TempDir()
-	script := fmt.Sprintf("#!/bin/sh\necho %s >&2\nexit %d\n", shellQuote(stderr), exitCode)
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "pkexec"), []byte(script), 0o700), "write the fake pkexec")
-	t.Setenv("PATH", dir)
-}
-
-func shellQuote(s string) string {
-	return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
-}
-
-func TestRunMapsPkexecExitCodes(t *testing.T) {
-	tests := []struct {
-		name     string
-		exitCode int
-		stderr   string
-		wantErr  error
-	}{
-		{name: "applied", exitCode: 0},
-		{
-			name:     "dialog dismissed",
-			exitCode: exitDismissed,
-			stderr:   "Error executing command as another user: Request dismissed",
-			wantErr:  ErrDeclined,
-		},
-		{
-			// What a graphical agent reports for a cancelled prompt. Not a
-			// failure: the user was asked and answered.
-			name:     "prompt cancelled",
-			exitCode: exitNotAuthorized,
-			stderr:   "Error executing command as another user: Not authorized",
-			wantErr:  ErrDeclined,
-		},
-		{
-			// The same status, but pkexec never got to ask anybody.
-			name:     "no agent and no terminal to fall back on",
-			exitCode: exitNotAuthorized,
-			stderr:   "Error creating textual authentication agent: Error opening current controlling terminal for the process (`/dev/tty'): No such device or address",
-			wantErr:  ErrUnavailable,
-		},
-		{
-			// And the same status again once the authorization succeeded and
-			// pkexec could not run what it had been authorized to run. Reading
-			// that as a refusal would revert the control in silence on a host
-			// where elevation is broken.
-			name:     "authorized but not runnable",
-			exitCode: exitNotAuthorized,
-			stderr:   "Error executing command as another user: No such file or directory",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			fakePkexec(t, tt.exitCode, tt.stderr)
-
-			err := run(context.Background(), "/nonexistent/netbird-ui", []string{"--flag"})
-			switch {
-			case tt.wantErr != nil:
-				require.ErrorIs(t, err, tt.wantErr, "exit %d said %q", tt.exitCode, tt.stderr)
-			case tt.exitCode == 0:
-				require.NoError(t, err, "a pkexec that exited cleanly applied the change")
-			default:
-				require.Error(t, err, "exit %d said %q", tt.exitCode, tt.stderr)
-				assert.NotErrorIs(t, err, ErrDeclined, "not the user's answer")
-				assert.NotErrorIs(t, err, ErrUnavailable, "not a missing mechanism")
-			}
-		})
-	}
-}
-
-// An exit code that is not polkit's is the one-shot's own failure, and has to
-// stay distinguishable from a declined prompt: the caller reports it.
-func TestRunReportsOneShotFailure(t *testing.T) {
-	fakePkexec(t, 3, "the one-shot said no")
-
-	err := run(context.Background(), "/nonexistent/netbird-ui", nil)
-
-	require.Error(t, err, "a one-shot that failed is not a prompt that was answered")
-	assert.NotErrorIs(t, err, ErrDeclined, "not the user's answer")
-	assert.NotErrorIs(t, err, ErrUnavailable, "not a missing mechanism")
-}
-
-func TestRunWithoutPkexecIsUnavailable(t *testing.T) {
-	t.Setenv("PATH", t.TempDir())
-
-	err := run(context.Background(), "/nonexistent/netbird-ui", nil)
-	require.ErrorIs(t, err, ErrUnavailable, "no pkexec means no mechanism")
-	assert.False(t, mechanismAvailable(), "mechanismAvailable without pkexec on PATH")
-}

client/internal/elevate/run_unsupported.go

@@ -1,15 +0,0 @@
-//go:build !windows && !darwin && !linux && !freebsd
-
-package elevate
-
-import "context"
-
-// run reports that this platform has no elevation prompt to drive. Mobile and
-// WASM builds have no local user to ask in the first place.
-func run(context.Context, string, []string) error {
-	return ErrUnavailable
-}
-
-func mechanismAvailable() bool {
-	return false
-}

client/internal/elevate/run_windows.go

@@ -1,193 +0,0 @@
-package elevate
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"runtime"
-	"unsafe"
-
-	log "github.com/sirupsen/logrus"
-	"golang.org/x/sys/windows"
-)
-
-const (
-	// seeMaskNoCloseProcess keeps the started process's handle open in
-	// hProcess so we can wait for it.
-	seeMaskNoCloseProcess = 0x00000040
-	// seeMaskNoAsync makes ShellExecuteExW finish its work before returning,
-	// which it must when the calling thread does not pump messages.
-	seeMaskNoAsync = 0x00000100
-	// seeMaskFlagNoUI suppresses the shell's own error dialogs; the UAC consent
-	// dialog is not one of them and still appears.
-	seeMaskFlagNoUI = 0x00000400
-
-	// swHide: the one-shot has no window to show.
-	swHide = 0
-
-	// sFalse (S_FALSE) answers CoInitializeEx when COM is already up on this
-	// thread in the mode we asked for; rpcChangedMode (RPC_E_CHANGED_MODE) when
-	// it is up in the other one.
-	sFalse         = 1
-	rpcChangedMode = 0x80010106
-)
-
-// shellExecuteInfoW mirrors SHELLEXECUTEINFOW. The field order and Go's own
-// padding match the C layout on both 386 and amd64.
-type shellExecuteInfoW struct {
-	cbSize         uint32
-	fMask          uint32
-	hwnd           windows.HWND
-	lpVerb         *uint16
-	lpFile         *uint16
-	lpParameters   *uint16
-	lpDirectory    *uint16
-	nShow          int32
-	hInstApp       windows.Handle
-	lpIDList       uintptr
-	lpClass        *uint16
-	hkeyClass      windows.Handle
-	dwHotKey       uint32
-	hIconOrMonitor windows.Handle
-	hProcess       windows.Handle
-}
-
-var (
-	shell32            = windows.NewLazySystemDLL("shell32.dll")
-	procShellExecuteEx = shell32.NewProc("ShellExecuteExW")
-)
-
-// run starts self elevated with the "runas" verb, which is what raises the UAC
-// consent dialog, and waits for it to finish. Windows decides whether consent is
-// enough or an administrator's credentials are needed, and collects them itself.
-func run(ctx context.Context, self string, args []string) error {
-	verb, err := windows.UTF16PtrFromString("runas")
-	if err != nil {
-		return fmt.Errorf("encode verb: %w", err)
-	}
-	file, err := windows.UTF16PtrFromString(self)
-	if err != nil {
-		return fmt.Errorf("encode %s: %w", self, err)
-	}
-	params, err := windows.UTF16PtrFromString(windows.ComposeCommandLine(args))
-	if err != nil {
-		return fmt.Errorf("encode arguments: %w", err)
-	}
-
-	info := shellExecuteInfoW{
-		fMask:        seeMaskNoCloseProcess | seeMaskNoAsync | seeMaskFlagNoUI,
-		hwnd:         ownerWindow(),
-		lpVerb:       verb,
-		lpFile:       file,
-		lpParameters: params,
-		nShow:        swHide,
-	}
-	info.cbSize = uint32(unsafe.Sizeof(info))
-
-	process, err := shellExecute(&info)
-	if err != nil {
-		return err
-	}
-	defer func() {
-		if err := windows.CloseHandle(process); err != nil {
-			log.Debugf("close elevated process handle: %v", err)
-		}
-	}()
-
-	return waitForProcess(ctx, process)
-}
-
-// shellExecute performs the call itself. ShellExecuteExW wants COM initialised on
-// the calling thread, so the goroutine is pinned to one for the duration and COM
-// is set up on it; an "already initialised, different mode" answer is fine,
-// because then somebody else has done it for us.
-func shellExecute(info *shellExecuteInfoW) (windows.Handle, error) {
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	switch err := windows.CoInitializeEx(0, windows.COINIT_APARTMENTTHREADED); {
-	case err == nil, isHResult(err, sFalse):
-		// Ours, or already initialised in the same mode: either way this call
-		// counts and has to be balanced.
-		defer windows.CoUninitialize()
-	case isHResult(err, rpcChangedMode):
-		// The thread is already in the other apartment model. ShellExecuteExW
-		// works there too, and there is nothing of ours to balance.
-	default:
-		return 0, fmt.Errorf("initialise COM: %w", err)
-	}
-
-	ret, _, lastErr := procShellExecuteEx.Call(uintptr(unsafe.Pointer(info)))
-	if ret != 0 {
-		return info.hProcess, nil
-	}
-
-	if errors.Is(lastErr, windows.ERROR_CANCELLED) {
-		return 0, ErrDeclined
-	}
-	return 0, fmt.Errorf("run elevated: %w", lastErr)
-}
-
-// ownerWindow returns this process's foreground window, and 0 when the window in
-// front belongs to somebody else or cannot be attributed. ShellExecuteExW takes it
-// as the parent for the UI it raises, which is what keeps the consent dialog in
-// front of the window the user was just clicking in instead of behind it. It is
-// also what a remote-desktop session needs to place the dialog at all when the
-// secure desktop is switched off.
-func ownerWindow() windows.HWND {
-	hwnd := windows.GetForegroundWindow()
-	if hwnd == 0 {
-		return 0
-	}
-
-	var pid uint32
-	if _, err := windows.GetWindowThreadProcessId(hwnd, &pid); err != nil {
-		log.Debugf("cannot attribute the foreground window, raising the prompt without an owner: %v", err)
-		return 0
-	}
-	if pid != windows.GetCurrentProcessId() {
-		return 0
-	}
-	return hwnd
-}
-
-// isHResult reports whether err carries the given HRESULT. CoInitializeEx
-// returns its HRESULT as an Errno, so the comparison is on the raw value.
-func isHResult(err error, hresult uintptr) bool {
-	var errno windows.Errno
-	return errors.As(err, &errno) && uintptr(errno) == hresult
-}
-
-func waitForProcess(ctx context.Context, process windows.Handle) error {
-	// The wait is interruptible so a cancelled context stops us waiting on a
-	// consent dialog nobody is going to answer. The elevated process is not
-	// ours to kill, and it either applies the change or does not.
-	for {
-		event, err := windows.WaitForSingleObject(process, 250)
-		if err != nil {
-			return fmt.Errorf("wait for the elevated process: %w", err)
-		}
-		if event == uint32(windows.WAIT_OBJECT_0) {
-			break
-		}
-		if err := ctx.Err(); err != nil {
-			return err
-		}
-	}
-
-	var code uint32
-	if err := windows.GetExitCodeProcess(process, &code); err != nil {
-		return fmt.Errorf("read the elevated process's exit code: %w", err)
-	}
-	if code != 0 {
-		return fmt.Errorf("elevated netbird exited with %d", code)
-	}
-	return nil
-}
-
-// mechanismAvailable is true on Windows: UAC prompts for consent when the user
-// is an administrator and for an administrator's credentials when they are not,
-// so there is always something to ask.
-func mechanismAvailable() bool {
-	return true
-}

client/internal/elevate/trusted.go

@@ -1,40 +0,0 @@
-package elevate
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-)
-
-// trustedSelf returns the path of this executable, provided it is one we are
-// willing to have run as root.
-//
-// The check is what keeps elevation from becoming a way to launder someone
-// else's code into a root process: the user consents to NetBird being elevated,
-// having been shown NetBird's name, so what runs must be the file NetBird was
-// installed as and not something a third party could have swapped for it. An
-// executable only its owner can write is that; anything wider is refused, and
-// the caller falls back to showing the command instead.
-//
-// The owner writing to their own executable is not part of that threat: code
-// running as the user can already prompt them for anything, and could just as
-// well ask them to run the command by hand. What matters is that no *other*
-// unprivileged account can reach it.
-func trustedSelf() (string, error) {
-	exe, err := os.Executable()
-	if err != nil {
-		return "", fmt.Errorf("locate this executable: %w", err)
-	}
-
-	// Resolve symlinks so the checks below apply to the file that would actually
-	// be executed, not to a link somebody else may control.
-	resolved, err := filepath.EvalSymlinks(exe)
-	if err != nil {
-		return "", fmt.Errorf("resolve %s: %w", exe, err)
-	}
-
-	if err := checkOnlyOwnerWritable(resolved); err != nil {
-		return "", fmt.Errorf("%w: %s cannot be trusted to run as root: %w", ErrUnavailable, resolved, err)
-	}
-	return resolved, nil
-}

client/internal/elevate/trusted_group_darwin.go

@@ -1,10 +0,0 @@
-package elevate
-
-// adminWriteGIDs are the groups whose write access to an executable does not
-// widen who could authorize elevating it.
-//
-// macOS installs applications as root:admin, mode 0775, /Applications included,
-// so requiring owner-only write would reject every normal install. Group admin
-// (gid 80) is exactly the set of accounts that can answer the authentication
-// dialog, so its write access grants nothing the prompt would not.
-var adminWriteGIDs = []uint32{0, 80}

client/internal/elevate/trusted_group_unix.go

@@ -1,9 +0,0 @@
-//go:build !windows && !darwin
-
-package elevate
-
-// adminWriteGIDs are the groups whose write access to an executable does not
-// widen who could authorize elevating it. Only root's own group qualifies here:
-// a distribution installs into root-owned directories, and there is no
-// system-wide administrators group that both writes them and answers polkit.
-var adminWriteGIDs = []uint32{0}

client/internal/elevate/trusted_unix.go

@@ -1,146 +0,0 @@
-//go:build !windows
-
-package elevate
-
-import (
-	"bufio"
-	"errors"
-	"fmt"
-	"os"
-	"os/user"
-	"path/filepath"
-	"slices"
-	"strconv"
-	"strings"
-	"syscall"
-
-	log "github.com/sirupsen/logrus"
-)
-
-// groupFile lists which accounts are in which group, for the membership a user
-// private group's name does not state: see groupHasOtherMembers.
-const groupFile = "/etc/group"
-
-// checkOnlyOwnerWritable reports an error unless path, and every directory leading
-// to it, is owned by either root or this user and writable by nobody who could not
-// already act as its owner. A writable directory is as good as a writable file,
-// since anything in it can be replaced, so the whole chain is checked.
-func checkOnlyOwnerWritable(path string) error {
-	self := uint32(os.Getuid())
-
-	for dir := path; ; dir = filepath.Dir(dir) {
-		info, err := os.Lstat(dir)
-		if err != nil {
-			return fmt.Errorf("stat %s: %w", dir, err)
-		}
-
-		stat, ok := info.Sys().(*syscall.Stat_t)
-		if !ok {
-			return errors.New("file ownership is unavailable on this platform")
-		}
-		if stat.Uid != 0 && stat.Uid != self {
-			return fmt.Errorf("%s is owned by uid %d, neither root nor this user", dir, stat.Uid)
-		}
-
-		if err := checkWriteBits(dir, info, stat.Uid, stat.Gid); err != nil {
-			return err
-		}
-
-		if parent := filepath.Dir(dir); parent == dir {
-			return nil
-		}
-	}
-}
-
-func checkWriteBits(path string, info os.FileInfo, uid, gid uint32) error {
-	// On a directory the sticky bit stands in for the write bits: whoever may
-	// write there still cannot replace an entry they do not own, which is the
-	// only thing that would matter to us. /tmp is the usual example.
-	sticky := info.IsDir() && info.Mode()&os.ModeSticky != 0
-
-	return writeBitsAllow(path, info.Mode().Perm(), sticky, groupWriteAllowed(uid, gid))
-}
-
-// writeBitsAllow decides on the permission bits alone, given whether the group's
-// write access has been vouched for.
-func writeBitsAllow(path string, perm os.FileMode, sticky, groupAllowed bool) error {
-	if sticky {
-		return nil
-	}
-	if perm&0o020 != 0 && !groupAllowed {
-		return fmt.Errorf("%s is writable by a group with members other than its owner (%v)", path, perm)
-	}
-	if perm&0o002 != 0 {
-		return fmt.Errorf("%s is world-writable (%v)", path, perm)
-	}
-	return nil
-}
-
-// groupWriteAllowed reports whether a group's write access to a file owned by uid
-// puts it in reach of anyone who could not already act as that owner.
-//
-// Two ways it does not. A group in adminWriteGIDs holds the accounts that can
-// answer the elevation prompt anyway. And a user private group is how Debian,
-// Ubuntu and Fedora ship: their umask of 002 makes a home directory and
-// everything built in it group-writable, so refusing that would refuse every
-// build not installed from a package.
-func groupWriteAllowed(uid, gid uint32) bool {
-	if slices.Contains(adminWriteGIDs, gid) {
-		return true
-	}
-
-	group, err := user.LookupGroupId(strconv.FormatUint(uint64(gid), 10))
-	if err != nil {
-		log.Debugf("cannot look up group %d, treating it as shared: %v", gid, err)
-		return false
-	}
-	owner, err := user.LookupId(strconv.FormatUint(uint64(uid), 10))
-	if err != nil {
-		log.Debugf("cannot look up uid %d, treating its group as shared: %v", uid, err)
-		return false
-	}
-
-	if group.Name != owner.Username {
-		return false
-	}
-	return !groupHasOtherMembers(groupFile, group.Name, owner.Username)
-}
-
-// groupHasOtherMembers reports whether the group lists a member besides owner.
-//
-// Sharing the owner's name is what a user private group is recognised by, and it
-// says nothing about who is in it: a group that has since gained a member is
-// still named that way, and that member can write whatever the group can. So the
-// membership is read rather than assumed. A group this file does not describe,
-// because it comes from LDAP or another NSS source, cannot be answered here and
-// leaves the name as the only thing to go on.
-func groupHasOtherMembers(path, name, owner string) bool {
-	file, err := os.Open(path)
-	if err != nil {
-		log.Debugf("cannot read %s for the members of group %q: %v", path, name, err)
-		return false
-	}
-	defer func() {
-		if err := file.Close(); err != nil {
-			log.Debugf("close %s: %v", path, err)
-		}
-	}()
-
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		// name:password:gid:member,member
-		fields := strings.Split(scanner.Text(), ":")
-		if len(fields) < 4 || fields[0] != name {
-			continue
-		}
-		for member := range strings.SplitSeq(fields[3], ",") {
-			if member != "" && member != owner {
-				return true
-			}
-		}
-	}
-	if err := scanner.Err(); err != nil {
-		log.Debugf("read %s: %v", path, err)
-	}
-	return false
-}

client/internal/elevate/trusted_unix_test.go

@@ -1,177 +0,0 @@
-//go:build !windows
-
-package elevate
-
-import (
-	"os"
-	"os/user"
-	"path/filepath"
-	"strconv"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ownerOnlyDir is t.TempDir() with the write bits tightened. testing creates its
-// numbered directory with 0777 minus the umask, so under the common 002 umask it
-// is group-writable and would fail the check under test on its own.
-func ownerOnlyDir(t *testing.T) string {
-	t.Helper()
-	dir := t.TempDir()
-	require.NoError(t, os.Chmod(dir, 0o755), "tighten the temporary directory")
-	return dir
-}
-
-// writeExecutable creates a plain executable file, the shape trustedSelf checks.
-func writeExecutable(t *testing.T, dir string) string {
-	t.Helper()
-	path := filepath.Join(dir, "netbird-ui")
-	require.NoError(t, os.WriteFile(path, []byte("#!/bin/sh\n"), 0o755), "write the executable")
-	require.NoError(t, os.Chmod(path, 0o755), "set the executable's mode")
-	return path
-}
-
-func TestCheckOnlyOwnerWritableAcceptsOwnerOnly(t *testing.T) {
-	err := checkOnlyOwnerWritable(writeExecutable(t, ownerOnlyDir(t)))
-	assert.NoError(t, err, "an owner-only writable executable is trustworthy")
-}
-
-func TestCheckOnlyOwnerWritableRejectsWorldWritableFile(t *testing.T) {
-	path := writeExecutable(t, ownerOnlyDir(t))
-	require.NoError(t, os.Chmod(path, 0o777), "make the executable world-writable")
-
-	assert.Error(t, checkOnlyOwnerWritable(path), "a world-writable executable must be refused")
-}
-
-// The permission policy on its own, without a filesystem to arrange: whether the
-// group has been vouched for is the only thing that makes group write acceptable.
-func TestWriteBitsAllow(t *testing.T) {
-	tests := []struct {
-		name         string
-		perm         os.FileMode
-		sticky       bool
-		groupAllowed bool
-		wantErr      bool
-	}{
-		{name: "owner only", perm: 0o755},
-		{name: "group write in a private group", perm: 0o775, groupAllowed: true},
-		{name: "group write in a shared group", perm: 0o775, wantErr: true},
-		{name: "world write", perm: 0o777, groupAllowed: true, wantErr: true},
-		{name: "world write on a sticky directory", perm: 0o777, sticky: true},
-		{name: "group write on a sticky directory", perm: 0o775, sticky: true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := writeBitsAllow("/path", tt.perm, tt.sticky, tt.groupAllowed)
-			if tt.wantErr {
-				assert.Error(t, err, "perm %v, sticky %v, group allowed %v", tt.perm, tt.sticky, tt.groupAllowed)
-				return
-			}
-			assert.NoError(t, err, "perm %v, sticky %v, group allowed %v", tt.perm, tt.sticky, tt.groupAllowed)
-		})
-	}
-}
-
-// A build under a home directory on a distribution with a 002 umask, which is what
-// a locally built or tarball-installed binary looks like. Its group has no members
-// but its owner, so it is as good as owner-only.
-//
-// Whether this host is such a distribution is read from the environment rather than
-// from groupWriteAllowed: asking the function under test whether to run would let
-// it skip its own coverage away if it regressed to refusing everything.
-func TestCheckOnlyOwnerWritableAcceptsOwnPrivateGroup(t *testing.T) {
-	requirePrivatePrimaryGroup(t)
-
-	dir := ownerOnlyDir(t)
-	path := writeExecutable(t, dir)
-	require.NoError(t, os.Chmod(dir, 0o775), "make the directory group-writable")
-	require.NoError(t, os.Chmod(path, 0o775), "make the executable group-writable")
-
-	err := checkOnlyOwnerWritable(path)
-	assert.NoError(t, err, "group write in the owner's own private group reaches nobody else")
-}
-
-// A group that shares its owner's name but has gained another member is no longer
-// private, and its write access reaches an account that could not elevate.
-func TestGroupHasOtherMembers(t *testing.T) {
-	tests := []struct {
-		name  string
-		entry string
-		want  bool
-	}{
-		{name: "no members", entry: "vma:x:1000:"},
-		{name: "only the owner", entry: "vma:x:1000:vma"},
-		{name: "another member", entry: "vma:x:1000:bob", want: true},
-		{name: "the owner and another", entry: "vma:x:1000:vma,bob", want: true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			path := filepath.Join(t.TempDir(), "group")
-			body := "root:x:0:\n" + tt.entry + "\nsudo:x:27:vma\n"
-			require.NoError(t, os.WriteFile(path, []byte(body), 0o644), "write the group file")
-
-			assert.Equal(t, tt.want, groupHasOtherMembers(path, "vma", "vma"), "entry %q", tt.entry)
-		})
-	}
-}
-
-// A group file that says nothing about the group leaves the name as the only thing
-// to go on, so the private-group allowance stands rather than collapsing on every
-// host whose groups come from LDAP.
-func TestGroupHasOtherMembersTolerantOfAnUnknownGroup(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "group")
-	require.NoError(t, os.WriteFile(path, []byte("root:x:0:\n"), 0o644), "write the group file")
-
-	assert.False(t, groupHasOtherMembers(path, "vma", "vma"), "a group the file does not describe")
-	assert.False(t, groupHasOtherMembers(filepath.Join(t.TempDir(), "absent"), "vma", "vma"),
-		"no group file at all")
-}
-
-// A writable directory is as good as a writable file: whoever can write the
-// directory can put a different binary at the same path.
-func TestCheckOnlyOwnerWritableRejectsWritableDirectory(t *testing.T) {
-	dir := filepath.Join(ownerOnlyDir(t), "bin")
-	require.NoError(t, os.Mkdir(dir, 0o755), "create the directory")
-	path := writeExecutable(t, dir)
-	require.NoError(t, os.Chmod(dir, 0o777), "make the directory world-writable")
-
-	assert.Error(t, checkOnlyOwnerWritable(path), "an executable in a world-writable directory must be refused")
-}
-
-// A sticky world-writable directory is exempt: the sticky bit is what stops one
-// user replacing another's entries. /tmp is why this matters.
-func TestCheckOnlyOwnerWritableAcceptsStickyDirectory(t *testing.T) {
-	dir := filepath.Join(ownerOnlyDir(t), "sticky")
-	require.NoError(t, os.Mkdir(dir, 0o755), "create the directory")
-	path := writeExecutable(t, dir)
-	require.NoError(t, os.Chmod(dir, 0o777|os.ModeSticky), "make the directory sticky and world-writable")
-
-	err := checkOnlyOwnerWritable(path)
-	assert.NoError(t, err, "the sticky bit stops another user replacing the executable")
-}
-
-func TestCheckOnlyOwnerWritableRejectsMissingFile(t *testing.T) {
-	err := checkOnlyOwnerWritable(filepath.Join(ownerOnlyDir(t), "absent"))
-	assert.Error(t, err, "an executable that is not there must be refused")
-}
-
-// requirePrivatePrimaryGroup skips unless this user's primary group is their own,
-// which is what the user-private-group allowance is about.
-func requirePrivatePrimaryGroup(t *testing.T) {
-	t.Helper()
-
-	self, err := user.Current()
-	require.NoError(t, err, "look up the test user")
-	group, err := user.LookupGroupId(strconv.Itoa(os.Getgid()))
-	require.NoError(t, err, "look up the test user's primary group")
-
-	if group.Name != self.Username {
-		t.Skipf("the test user's primary group is %q, not their own, so there is nothing to assert here", group.Name)
-	}
-	if groupHasOtherMembers(groupFile, group.Name, self.Username) {
-		t.Skipf("group %q has other members, so it is not a private group", group.Name)
-	}
-}

client/internal/elevate/trusted_windows.go

@@ -1,215 +0,0 @@
-package elevate
-
-import (
-	"errors"
-	"fmt"
-	"path/filepath"
-	"slices"
-	"unsafe"
-
-	"golang.org/x/sys/windows"
-)
-
-const (
-	// fileDeleteChild is FILE_DELETE_CHILD, which x/sys does not define: the
-	// right to delete an entry of a directory without holding DELETE on it.
-	fileDeleteChild = 0x00000040
-
-	// accessAllowedCallbackACEType is an allow ACE with a condition appended to
-	// the ACCESS_ALLOWED_ACE layout, so its trustee is still at SidStart.
-	accessAllowedCallbackACEType = 0x9
-
-	// The allow ACE types that carry object GUIDs ahead of the trustee, so the
-	// SID is not at SidStart. They occur on directory-service objects rather
-	// than files, and are refused rather than skipped: see aceTrustee.
-	accessAllowedObjectACEType         = 0x5
-	accessAllowedCallbackObjectACEType = 0xB
-)
-
-// fileWriteAccess are the rights that let a trustee rewrite or replace a file,
-// or take it over and then do so.
-const fileWriteAccess = windows.FILE_WRITE_DATA | windows.FILE_APPEND_DATA |
-	windows.DELETE | windows.WRITE_DAC | windows.WRITE_OWNER |
-	windows.GENERIC_WRITE | windows.GENERIC_ALL
-
-// dirWriteAccess are the rights over a directory that let a trustee replace an
-// entry somebody else owns. Creating a new entry is not one of them, which is
-// what the Unix sticky bit says in one bit: the root of every volume grants
-// BUILTIN\Users the right to add directories under it, and that reaches nothing
-// already there.
-const dirWriteAccess = fileDeleteChild | windows.DELETE |
-	windows.WRITE_DAC | windows.WRITE_OWNER | windows.GENERIC_ALL
-
-// trustedInstallerSID owns much of what Windows itself installs. x/sys has no
-// well-known constant for it.
-const trustedInstallerSID = "S-1-5-80-956008885-3418522649-1831038044-1853292631-2271478464"
-
-// checkOnlyOwnerWritable reports an error unless path, and every directory
-// leading to it, is owned by an account that can elevate (or by this user) and
-// grants write access to nobody else. A writable directory is as good as a
-// writable file, since an entry in it can be replaced, so the whole chain is
-// checked.
-func checkOnlyOwnerWritable(path string) error {
-	owners, err := trustedOwners()
-	if err != nil {
-		return err
-	}
-	writers, err := trustedWriters(owners)
-	if err != nil {
-		return err
-	}
-
-	writeAccess := windows.ACCESS_MASK(fileWriteAccess)
-	for target := path; ; target = filepath.Dir(target) {
-		if err := checkSecurity(target, writeAccess, owners, writers); err != nil {
-			return err
-		}
-		if parent := filepath.Dir(target); parent == target {
-			return nil
-		}
-		writeAccess = dirWriteAccess
-	}
-}
-
-// trustedOwners are the accounts we accept as the owner of the executable and of
-// the directories above it: the ones that can already answer the UAC prompt,
-// plus this user, whose own executable is theirs to write. Code running as the
-// user could prompt them for anything anyway; what matters is that no *other*
-// unprivileged account can reach it.
-func trustedOwners() ([]*windows.SID, error) {
-	self, err := currentUserSID()
-	if err != nil {
-		return nil, err
-	}
-
-	owners := []*windows.SID{self}
-	for _, wellKnown := range []windows.WELL_KNOWN_SID_TYPE{
-		windows.WinLocalSystemSid,
-		windows.WinBuiltinAdministratorsSid,
-	} {
-		sid, err := windows.CreateWellKnownSid(wellKnown)
-		if err != nil {
-			return nil, fmt.Errorf("build well-known SID %d: %w", wellKnown, err)
-		}
-		owners = append(owners, sid)
-	}
-
-	installer, err := windows.StringToSid(trustedInstallerSID)
-	if err != nil {
-		return nil, fmt.Errorf("parse TrustedInstaller SID: %w", err)
-	}
-	return append(owners, installer), nil
-}
-
-// trustedWriters are the trustees whose write access does not widen who could
-// decide what runs behind the prompt. The owners, and CREATOR OWNER, which
-// resolves to the object's owner and is therefore already vetted.
-func trustedWriters(owners []*windows.SID) ([]*windows.SID, error) {
-	creatorOwner, err := windows.CreateWellKnownSid(windows.WinCreatorOwnerSid)
-	if err != nil {
-		return nil, fmt.Errorf("build the CREATOR OWNER SID: %w", err)
-	}
-	return append(slices.Clone(owners), creatorOwner), nil
-}
-
-func checkSecurity(path string, writeAccess windows.ACCESS_MASK, owners, writers []*windows.SID) error {
-	sd, err := windows.GetNamedSecurityInfo(path, windows.SE_FILE_OBJECT,
-		windows.OWNER_SECURITY_INFORMATION|windows.DACL_SECURITY_INFORMATION)
-	if err != nil {
-		return fmt.Errorf("read security descriptor of %s: %w", path, err)
-	}
-
-	owner, _, err := sd.Owner()
-	if err != nil {
-		return fmt.Errorf("read owner of %s: %w", path, err)
-	}
-	if !containsSID(owners, owner) {
-		return fmt.Errorf("%s is owned by %s, which is neither this user nor an account that can elevate", path, owner)
-	}
-
-	dacl, _, err := sd.DACL()
-	if err != nil {
-		return fmt.Errorf("read DACL of %s: %w", path, err)
-	}
-	// A NULL DACL grants everyone everything; only an absent security
-	// descriptor would have got us here without one, and neither is trustworthy.
-	if dacl == nil {
-		return fmt.Errorf("%s has no DACL, so it grants write access to everyone", path)
-	}
-
-	return checkDACL(path, dacl, writeAccess, writers)
-}
-
-// checkDACL refuses an ACL that grants write access to a trustee outside
-// writers.
-//
-// An allowlist, because the trustees that must not have it cannot be listed: an
-// ACE naming an ordinary user account hands that account the same power as one
-// naming Everyone, and only the accounts that may hold it are knowable.
-func checkDACL(path string, dacl *windows.ACL, writeAccess windows.ACCESS_MASK, writers []*windows.SID) error {
-	for i := uint32(0); i < uint32(dacl.AceCount); i++ {
-		var ace *windows.ACCESS_ALLOWED_ACE
-		if err := windows.GetAce(dacl, i, &ace); err != nil {
-			return fmt.Errorf("read ACE %d of %s: %w", i, path, err)
-		}
-		// An inherit-only ACE says what children of this object get, not what
-		// this object grants.
-		if ace.Header.AceFlags&windows.INHERIT_ONLY_ACE != 0 {
-			continue
-		}
-		if ace.Mask&writeAccess == 0 {
-			continue
-		}
-		// Only an allow ACE grants anything; a deny ACE narrows what one gave.
-		if !isAllowACE(ace.Header.AceType) {
-			continue
-		}
-
-		trustee, err := aceTrustee(ace)
-		if err != nil {
-			return fmt.Errorf("read the trustee of ACE %d of %s: %w", i, path, err)
-		}
-		if !containsSID(writers, trustee) {
-			return fmt.Errorf("%s grants write access to %s", path, trustee)
-		}
-	}
-	return nil
-}
-
-// isAllowACE reports whether an ACE type grants rights, rather than denying,
-// auditing or labelling them.
-func isAllowACE(aceType uint8) bool {
-	switch aceType {
-	case windows.ACCESS_ALLOWED_ACE_TYPE, accessAllowedCallbackACEType,
-		accessAllowedObjectACEType, accessAllowedCallbackObjectACEType:
-		return true
-	default:
-		return false
-	}
-}
-
-// aceTrustee returns who an allow ACE grants its rights to. An ACE whose trustee
-// cannot be located is an error rather than something to skip past: being unable
-// to read who is being given write access is a refusal.
-func aceTrustee(ace *windows.ACCESS_ALLOWED_ACE) (*windows.SID, error) {
-	switch ace.Header.AceType {
-	case windows.ACCESS_ALLOWED_ACE_TYPE, accessAllowedCallbackACEType:
-		//nolint:gosec // SidStart is the first uint32 of the variable-length SID that follows the ACE header.
-		return (*windows.SID)(unsafe.Pointer(&ace.SidStart)), nil
-	default:
-		return nil, errors.New("an object-type allow ACE does not carry its trustee where we can read it")
-	}
-}
-
-func containsSID(sids []*windows.SID, sid *windows.SID) bool {
-	return slices.ContainsFunc(sids, sid.Equals)
-}
-
-func currentUserSID() (*windows.SID, error) {
-	token := windows.GetCurrentProcessToken()
-	user, err := token.GetTokenUser()
-	if err != nil {
-		return nil, fmt.Errorf("read this process's user: %w", err)
-	}
-	return user.User.Sid, nil
-}

client/internal/elevate/trusted_windows_test.go

@@ -1,126 +0,0 @@
-package elevate
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"golang.org/x/sys/windows"
-)
-
-// A file the test user created under their own profile, which is what a per-user
-// install looks like. The whole chain up to the volume root is walked, so this is
-// also what says the walk does not refuse an ordinary Windows installation: the
-// root of every volume grants BUILTIN\Users rights that are not ours to worry
-// about.
-func TestCheckOnlyOwnerWritableAcceptsOwnFile(t *testing.T) {
-	err := checkOnlyOwnerWritable(writeExecutable(t))
-	assert.NoError(t, err, "a file the test user owns, under directories only administrators can write")
-}
-
-// Write access held by an account that cannot answer the UAC prompt means that
-// account decides what runs behind it, whoever the ACE names. The trustees that
-// must not have it cannot be listed, so the check names the ones that may.
-func TestCheckOnlyOwnerWritableRejectsUntrustedWriters(t *testing.T) {
-	tests := []struct {
-		name      string
-		wellKnown windows.WELL_KNOWN_SID_TYPE
-	}{
-		{name: "everyone", wellKnown: windows.WinWorldSid},
-		{name: "authenticated users", wellKnown: windows.WinAuthenticatedUserSid},
-		{name: "builtin users", wellKnown: windows.WinBuiltinUsersSid},
-		// A service account, which no denylist of the obvious groups would name
-		// and which cannot elevate any more than Everyone can.
-		{name: "local service", wellKnown: windows.WinLocalServiceSid},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			path := writeExecutable(t)
-			grantWrite(t, path, tt.wellKnown)
-
-			assert.Error(t, checkOnlyOwnerWritable(path),
-				"write access for %s must be refused", tt.name)
-		})
-	}
-}
-
-// The masks are the policy: on a file any write reaches its contents, while on a
-// directory only deleting or taking over an entry reaches something already
-// there. Adding an entry does not, which is why the walk survives a volume root.
-func TestWriteAccessMasks(t *testing.T) {
-	assert.NotZero(t, fileWriteAccess&windows.FILE_WRITE_DATA, "writing a file's data reaches its contents")
-	assert.NotZero(t, fileWriteAccess&windows.FILE_APPEND_DATA, "appending to a file reaches its contents")
-
-	assert.Zero(t, dirWriteAccess&windows.FILE_WRITE_DATA, "adding a file to a directory replaces nothing")
-	assert.Zero(t, dirWriteAccess&windows.FILE_APPEND_DATA, "adding a subdirectory replaces nothing")
-	assert.NotZero(t, dirWriteAccess&fileDeleteChild, "deleting an entry replaces it")
-	assert.NotZero(t, dirWriteAccess&windows.DELETE, "deleting the directory takes its entries with it")
-}
-
-func TestIsAllowACE(t *testing.T) {
-	tests := []struct {
-		name    string
-		aceType uint8
-		want    bool
-	}{
-		{name: "allowed", aceType: windows.ACCESS_ALLOWED_ACE_TYPE, want: true},
-		{name: "allowed callback", aceType: accessAllowedCallbackACEType, want: true},
-		{name: "allowed object", aceType: accessAllowedObjectACEType, want: true},
-		{name: "allowed callback object", aceType: accessAllowedCallbackObjectACEType, want: true},
-		{name: "denied", aceType: windows.ACCESS_DENIED_ACE_TYPE},
-		// SYSTEM_AUDIT_ACE_TYPE, which x/sys does not define: an ACE that records
-		// access rather than granting it.
-		{name: "audit", aceType: 0x2},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			assert.Equal(t, tt.want, isAllowACE(tt.aceType), "ACE type %#x", tt.aceType)
-		})
-	}
-}
-
-// writeExecutable creates a plain file under the test's own directory, the shape
-// trustedSelf checks.
-func writeExecutable(t *testing.T) string {
-	t.Helper()
-	path := filepath.Join(t.TempDir(), "netbird-ui.exe")
-	require.NoError(t, os.WriteFile(path, []byte("MZ"), 0o755), "write the executable")
-	return path
-}
-
-// grantWrite replaces the file's DACL with one that grants a well-known trustee
-// everything, keeping the test user's own access so the file stays deletable.
-func grantWrite(t *testing.T, path string, wellKnown windows.WELL_KNOWN_SID_TYPE) {
-	t.Helper()
-
-	trustee, err := windows.CreateWellKnownSid(wellKnown)
-	require.NoError(t, err, "build the trustee SID")
-	self, err := currentUserSID()
-	require.NoError(t, err, "read the test user's SID")
-
-	acl, err := windows.ACLFromEntries([]windows.EXPLICIT_ACCESS{
-		fullControl(self, windows.TRUSTEE_IS_USER),
-		fullControl(trustee, windows.TRUSTEE_IS_WELL_KNOWN_GROUP),
-	}, nil)
-	require.NoError(t, err, "build the ACL")
-
-	require.NoError(t, windows.SetNamedSecurityInfo(path, windows.SE_FILE_OBJECT,
-		windows.DACL_SECURITY_INFORMATION|windows.PROTECTED_DACL_SECURITY_INFORMATION,
-		nil, nil, acl, nil), "set the DACL")
-}
-
-func fullControl(sid *windows.SID, trusteeType uint32) windows.EXPLICIT_ACCESS {
-	return windows.EXPLICIT_ACCESS{
-		AccessPermissions: windows.GENERIC_ALL,
-		AccessMode:        windows.GRANT_ACCESS,
-		Trustee: windows.TRUSTEE{
-			TrusteeForm:  windows.TRUSTEE_IS_SID,
-			TrusteeType:  windows.TRUSTEE_TYPE(trusteeType),
-			TrusteeValue: windows.TrusteeValueFromSID(sid),
-		},
-	}
-}

client/internal/engine.go

@@ -2200,6 +2200,19 @@ func (e *Engine) GetExposeManager() *expose.Manager {
 	return e.exposeManager
 }
 
+// GetAgentNetworkSetup asks the management server for the Agent Network
+// connection info this peer's groups authorize, over the engine's
+// existing management connection.
+func (e *Engine) GetAgentNetworkSetup(ctx context.Context) (*mgmProto.AgentNetworkSetupResponse, error) {
+	e.syncMsgMux.Lock()
+	mgmClient := e.mgmClient
+	e.syncMsgMux.Unlock()
+	if mgmClient == nil {
+		return nil, errors.New("management client not available")
+	}
+	return mgmClient.GetAgentNetworkSetup(ctx)
+}
+
 // IsBlockInbound returns whether inbound connections are blocked.
 func (e *Engine) IsBlockInbound() bool {
 	return e.config.BlockInbound

client/internal/ipcauth/privileged.go

@@ -91,12 +91,6 @@ func SelfDelegatesTo() (Identity, bool) {
 	return selfIdentity, true
 }
 
-// The values PrivilegedActorKey returns.
-const (
-	ActorKeyAdministrator = "administrator"
-	ActorKeyRoot          = "root"
-)
-
 // PrivilegedActor names the principal a privileged operation requires, for use
 // in messages shown to the user.
 func PrivilegedActor() string {
@@ -106,16 +100,6 @@ func PrivilegedActor() string {
 	return "root"
 }
 
-// PrivilegedActorKey identifies that principal without wording it, for a client
-// that writes its own message in the user's language. The words PrivilegedActor
-// returns are English, and a translated sentence cannot borrow them.
-func PrivilegedActorKey() string {
-	if runtime.GOOS == "windows" {
-		return ActorKeyAdministrator
-	}
-	return ActorKeyRoot
-}
-
 // ElevatedCommand renders a command so that running it grants the privileges the
 // operation needs. Windows has no in-line equivalent of sudo, so the command is
 // returned unchanged and the user is expected to run it from an elevated

client/proto/daemon.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.36.6
-// 	protoc        v6.33.1
+// 	protoc        v7.34.1
 // source: daemon.proto
 
 package proto
@@ -6941,6 +6941,190 @@ func (*StopBundleCaptureResponse) Descriptor() ([]byte, []int) {
 	return file_daemon_proto_rawDescGZIP(), []int{106}
 }
 
+type GetAgentNetworkSetupRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GetAgentNetworkSetupRequest) Reset() {
+	*x = GetAgentNetworkSetupRequest{}
+	mi := &file_daemon_proto_msgTypes[107]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GetAgentNetworkSetupRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetAgentNetworkSetupRequest) ProtoMessage() {}
+
+func (x *GetAgentNetworkSetupRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_daemon_proto_msgTypes[107]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GetAgentNetworkSetupRequest.ProtoReflect.Descriptor instead.
+func (*GetAgentNetworkSetupRequest) Descriptor() ([]byte, []int) {
+	return file_daemon_proto_rawDescGZIP(), []int{107}
+}
+
+type GetAgentNetworkSetupResponse struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// configured is false when the account has no Agent Network set up or
+	// this peer's groups authorize none of it.
+	Configured bool `protobuf:"varint,1,opt,name=configured,proto3" json:"configured,omitempty"`
+	// endpoint is the account's proxy base URL, reachable over the NetBird
+	// tunnel only. Empty when configured is false.
+	Endpoint      string                  `protobuf:"bytes,2,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
+	Providers     []*AgentNetworkProvider `protobuf:"bytes,3,rep,name=providers,proto3" json:"providers,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GetAgentNetworkSetupResponse) Reset() {
+	*x = GetAgentNetworkSetupResponse{}
+	mi := &file_daemon_proto_msgTypes[108]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GetAgentNetworkSetupResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetAgentNetworkSetupResponse) ProtoMessage() {}
+
+func (x *GetAgentNetworkSetupResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_daemon_proto_msgTypes[108]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GetAgentNetworkSetupResponse.ProtoReflect.Descriptor instead.
+func (*GetAgentNetworkSetupResponse) Descriptor() ([]byte, []int) {
+	return file_daemon_proto_rawDescGZIP(), []int{108}
+}
+
+func (x *GetAgentNetworkSetupResponse) GetConfigured() bool {
+	if x != nil {
+		return x.Configured
+	}
+	return false
+}
+
+func (x *GetAgentNetworkSetupResponse) GetEndpoint() string {
+	if x != nil {
+		return x.Endpoint
+	}
+	return ""
+}
+
+func (x *GetAgentNetworkSetupResponse) GetProviders() []*AgentNetworkProvider {
+	if x != nil {
+		return x.Providers
+	}
+	return nil
+}
+
+type AgentNetworkProvider struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// name is the operator-assigned provider label, e.g. "Bedrock prod".
+	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	// catalog_id names the provider type, e.g. "anthropic_api", "bedrock_api".
+	CatalogId string `protobuf:"bytes,2,opt,name=catalog_id,json=catalogId,proto3" json:"catalog_id,omitempty"`
+	// api_flavor is the request-body shape the provider speaks ("anthropic",
+	// "openai"); empty when the proxy dispatches it by URL path instead.
+	ApiFlavor string `protobuf:"bytes,3,opt,name=api_flavor,json=apiFlavor,proto3" json:"api_flavor,omitempty"`
+	// all_models_allowed is true when no model allowlist restricts this
+	// provider for the caller.
+	AllModelsAllowed bool `protobuf:"varint,4,opt,name=all_models_allowed,json=allModelsAllowed,proto3" json:"all_models_allowed,omitempty"`
+	// models is the effective model allowlist (or the declared/catalog models
+	// when all_models_allowed is true).
+	Models        []string `protobuf:"bytes,5,rep,name=models,proto3" json:"models,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AgentNetworkProvider) Reset() {
+	*x = AgentNetworkProvider{}
+	mi := &file_daemon_proto_msgTypes[109]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AgentNetworkProvider) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AgentNetworkProvider) ProtoMessage() {}
+
+func (x *AgentNetworkProvider) ProtoReflect() protoreflect.Message {
+	mi := &file_daemon_proto_msgTypes[109]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use AgentNetworkProvider.ProtoReflect.Descriptor instead.
+func (*AgentNetworkProvider) Descriptor() ([]byte, []int) {
+	return file_daemon_proto_rawDescGZIP(), []int{109}
+}
+
+func (x *AgentNetworkProvider) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *AgentNetworkProvider) GetCatalogId() string {
+	if x != nil {
+		return x.CatalogId
+	}
+	return ""
+}
+
+func (x *AgentNetworkProvider) GetApiFlavor() string {
+	if x != nil {
+		return x.ApiFlavor
+	}
+	return ""
+}
+
+func (x *AgentNetworkProvider) GetAllModelsAllowed() bool {
+	if x != nil {
+		return x.AllModelsAllowed
+	}
+	return false
+}
+
+func (x *AgentNetworkProvider) GetModels() []string {
+	if x != nil {
+		return x.Models
+	}
+	return nil
+}
+
 type PortInfo_Range struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	Start         uint32                 `protobuf:"varint,1,opt,name=start,proto3" json:"start,omitempty"`
@@ -6951,7 +7135,7 @@ type PortInfo_Range struct {
 
 func (x *PortInfo_Range) Reset() {
 	*x = PortInfo_Range{}
-	mi := &file_daemon_proto_msgTypes[108]
+	mi := &file_daemon_proto_msgTypes[111]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -6963,7 +7147,7 @@ func (x *PortInfo_Range) String() string {
 func (*PortInfo_Range) ProtoMessage() {}
 
 func (x *PortInfo_Range) ProtoReflect() protoreflect.Message {
-	mi := &file_daemon_proto_msgTypes[108]
+	mi := &file_daemon_proto_msgTypes[111]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -7577,7 +7761,22 @@ const file_daemon_proto_rawDesc = "" +
 	"\atimeout\x18\x01 \x01(\v2\x19.google.protobuf.DurationR\atimeout\"\x1c\n" +
 	"\x1aStartBundleCaptureResponse\"\x1a\n" +
 	"\x18StopBundleCaptureRequest\"\x1b\n" +
-	"\x19StopBundleCaptureResponse*b\n" +
+	"\x19StopBundleCaptureResponse\"\x1d\n" +
+	"\x1bGetAgentNetworkSetupRequest\"\x96\x01\n" +
+	"\x1cGetAgentNetworkSetupResponse\x12\x1e\n" +
+	"\n" +
+	"configured\x18\x01 \x01(\bR\n" +
+	"configured\x12\x1a\n" +
+	"\bendpoint\x18\x02 \x01(\tR\bendpoint\x12:\n" +
+	"\tproviders\x18\x03 \x03(\v2\x1c.daemon.AgentNetworkProviderR\tproviders\"\xae\x01\n" +
+	"\x14AgentNetworkProvider\x12\x12\n" +
+	"\x04name\x18\x01 \x01(\tR\x04name\x12\x1d\n" +
+	"\n" +
+	"catalog_id\x18\x02 \x01(\tR\tcatalogId\x12\x1d\n" +
+	"\n" +
+	"api_flavor\x18\x03 \x01(\tR\tapiFlavor\x12,\n" +
+	"\x12all_models_allowed\x18\x04 \x01(\bR\x10allModelsAllowed\x12\x16\n" +
+	"\x06models\x18\x05 \x03(\tR\x06models*b\n" +
 	"\bLogLevel\x12\v\n" +
 	"\aUNKNOWN\x10\x00\x12\t\n" +
 	"\x05PANIC\x10\x01\x12\t\n" +
@@ -7595,7 +7794,7 @@ const file_daemon_proto_rawDesc = "" +
 	"\n" +
 	"EXPOSE_UDP\x10\x03\x12\x0e\n" +
 	"\n" +
-	"EXPOSE_TLS\x10\x042\xa3\x1c\n" +
+	"EXPOSE_TLS\x10\x042\x88\x1d\n" +
 	"\rDaemonService\x126\n" +
 	"\x05Login\x12\x14.daemon.LoginRequest\x1a\x15.daemon.LoginResponse\"\x00\x12K\n" +
 	"\fWaitSSOLogin\x12\x1b.daemon.WaitSSOLoginRequest\x1a\x1c.daemon.WaitSSOLoginResponse\"\x00\x12-\n" +
@@ -7645,7 +7844,8 @@ const file_daemon_proto_rawDesc = "" +
 	"\x0eStopCPUProfile\x12\x1d.daemon.StopCPUProfileRequest\x1a\x1e.daemon.StopCPUProfileResponse\"\x00\x12W\n" +
 	"\x12GetInstallerResult\x12\x1e.daemon.InstallerResultRequest\x1a\x1f.daemon.InstallerResultResponse\"\x00\x12M\n" +
 	"\rExposeService\x12\x1c.daemon.ExposeServiceRequest\x1a\x1a.daemon.ExposeServiceEvent\"\x000\x01\x12K\n" +
-	"\fWailsUIReady\x12\x1b.daemon.WailsUIReadyRequest\x1a\x1c.daemon.WailsUIReadyResponse\"\x00B\bZ\x06/protob\x06proto3"
+	"\fWailsUIReady\x12\x1b.daemon.WailsUIReadyRequest\x1a\x1c.daemon.WailsUIReadyResponse\"\x00\x12c\n" +
+	"\x14GetAgentNetworkSetup\x12#.daemon.GetAgentNetworkSetupRequest\x1a$.daemon.GetAgentNetworkSetupResponse\"\x00B\bZ\x06/protob\x06proto3"
 
 var (
 	file_daemon_proto_rawDescOnce sync.Once
@@ -7660,7 +7860,7 @@ func file_daemon_proto_rawDescGZIP() []byte {
 }
 
 var file_daemon_proto_enumTypes = make([]protoimpl.EnumInfo, 4)
-var file_daemon_proto_msgTypes = make([]protoimpl.MessageInfo, 110)
+var file_daemon_proto_msgTypes = make([]protoimpl.MessageInfo, 113)
 var file_daemon_proto_goTypes = []any{
 	(LogLevel)(0),                              // 0: daemon.LogLevel
 	(ExposeProtocol)(0),                        // 1: daemon.ExposeProtocol
@@ -7773,19 +7973,22 @@ var file_daemon_proto_goTypes = []any{
 	(*StartBundleCaptureResponse)(nil),         // 108: daemon.StartBundleCaptureResponse
 	(*StopBundleCaptureRequest)(nil),           // 109: daemon.StopBundleCaptureRequest
 	(*StopBundleCaptureResponse)(nil),          // 110: daemon.StopBundleCaptureResponse
-	nil,                                        // 111: daemon.Network.ResolvedIPsEntry
-	(*PortInfo_Range)(nil),                     // 112: daemon.PortInfo.Range
-	nil,                                        // 113: daemon.SystemEvent.MetadataEntry
-	(*durationpb.Duration)(nil),                // 114: google.protobuf.Duration
-	(*timestamppb.Timestamp)(nil),              // 115: google.protobuf.Timestamp
+	(*GetAgentNetworkSetupRequest)(nil),        // 111: daemon.GetAgentNetworkSetupRequest
+	(*GetAgentNetworkSetupResponse)(nil),       // 112: daemon.GetAgentNetworkSetupResponse
+	(*AgentNetworkProvider)(nil),               // 113: daemon.AgentNetworkProvider
+	nil,                                        // 114: daemon.Network.ResolvedIPsEntry
+	(*PortInfo_Range)(nil),                     // 115: daemon.PortInfo.Range
+	nil,                                        // 116: daemon.SystemEvent.MetadataEntry
+	(*durationpb.Duration)(nil),                // 117: google.protobuf.Duration
+	(*timestamppb.Timestamp)(nil),              // 118: google.protobuf.Timestamp
 }
 var file_daemon_proto_depIdxs = []int32{
-	114, // 0: daemon.LoginRequest.dnsRouteInterval:type_name -> google.protobuf.Duration
+	117, // 0: daemon.LoginRequest.dnsRouteInterval:type_name -> google.protobuf.Duration
 	25,  // 1: daemon.StatusResponse.fullStatus:type_name -> daemon.FullStatus
-	115, // 2: daemon.StatusResponse.sessionExpiresAt:type_name -> google.protobuf.Timestamp
-	115, // 3: daemon.PeerState.connStatusUpdate:type_name -> google.protobuf.Timestamp
-	115, // 4: daemon.PeerState.lastWireguardHandshake:type_name -> google.protobuf.Timestamp
-	114, // 5: daemon.PeerState.latency:type_name -> google.protobuf.Duration
+	118, // 2: daemon.StatusResponse.sessionExpiresAt:type_name -> google.protobuf.Timestamp
+	118, // 3: daemon.PeerState.connStatusUpdate:type_name -> google.protobuf.Timestamp
+	118, // 4: daemon.PeerState.lastWireguardHandshake:type_name -> google.protobuf.Timestamp
+	117, // 5: daemon.PeerState.latency:type_name -> google.protobuf.Duration
 	23,  // 6: daemon.SSHServerState.sessions:type_name -> daemon.SSHSessionInfo
 	20,  // 7: daemon.FullStatus.managementState:type_name -> daemon.ManagementState
 	19,  // 8: daemon.FullStatus.signalState:type_name -> daemon.SignalState
@@ -7796,8 +7999,8 @@ var file_daemon_proto_depIdxs = []int32{
 	57,  // 13: daemon.FullStatus.events:type_name -> daemon.SystemEvent
 	24,  // 14: daemon.FullStatus.sshServerState:type_name -> daemon.SSHServerState
 	31,  // 15: daemon.ListNetworksResponse.routes:type_name -> daemon.Network
-	111, // 16: daemon.Network.resolvedIPs:type_name -> daemon.Network.ResolvedIPsEntry
-	112, // 17: daemon.PortInfo.range:type_name -> daemon.PortInfo.Range
+	114, // 16: daemon.Network.resolvedIPs:type_name -> daemon.Network.ResolvedIPsEntry
+	115, // 17: daemon.PortInfo.range:type_name -> daemon.PortInfo.Range
 	32,  // 18: daemon.ForwardingRule.destinationPort:type_name -> daemon.PortInfo
 	32,  // 19: daemon.ForwardingRule.translatedPort:type_name -> daemon.PortInfo
 	33,  // 20: daemon.ForwardingRulesResponse.rules:type_name -> daemon.ForwardingRule
@@ -7808,114 +8011,117 @@ var file_daemon_proto_depIdxs = []int32{
 	54,  // 25: daemon.TracePacketResponse.stages:type_name -> daemon.TraceStage
 	2,   // 26: daemon.SystemEvent.severity:type_name -> daemon.SystemEvent.Severity
 	3,   // 27: daemon.SystemEvent.category:type_name -> daemon.SystemEvent.Category
-	115, // 28: daemon.SystemEvent.timestamp:type_name -> google.protobuf.Timestamp
-	113, // 29: daemon.SystemEvent.metadata:type_name -> daemon.SystemEvent.MetadataEntry
+	118, // 28: daemon.SystemEvent.timestamp:type_name -> google.protobuf.Timestamp
+	116, // 29: daemon.SystemEvent.metadata:type_name -> daemon.SystemEvent.MetadataEntry
 	57,  // 30: daemon.GetEventsResponse.events:type_name -> daemon.SystemEvent
-	114, // 31: daemon.SetConfigRequest.dnsRouteInterval:type_name -> google.protobuf.Duration
+	117, // 31: daemon.SetConfigRequest.dnsRouteInterval:type_name -> google.protobuf.Duration
 	72,  // 32: daemon.ListProfilesResponse.profiles:type_name -> daemon.Profile
-	115, // 33: daemon.WaitExtendAuthSessionResponse.sessionExpiresAt:type_name -> google.protobuf.Timestamp
+	118, // 33: daemon.WaitExtendAuthSessionResponse.sessionExpiresAt:type_name -> google.protobuf.Timestamp
 	1,   // 34: daemon.ExposeServiceRequest.protocol:type_name -> daemon.ExposeProtocol
 	104, // 35: daemon.ExposeServiceEvent.ready:type_name -> daemon.ExposeServiceReady
-	114, // 36: daemon.StartCaptureRequest.duration:type_name -> google.protobuf.Duration
-	114, // 37: daemon.StartBundleCaptureRequest.timeout:type_name -> google.protobuf.Duration
-	30,  // 38: daemon.Network.ResolvedIPsEntry.value:type_name -> daemon.IPList
-	5,   // 39: daemon.DaemonService.Login:input_type -> daemon.LoginRequest
-	7,   // 40: daemon.DaemonService.WaitSSOLogin:input_type -> daemon.WaitSSOLoginRequest
-	9,   // 41: daemon.DaemonService.Up:input_type -> daemon.UpRequest
-	11,  // 42: daemon.DaemonService.Status:input_type -> daemon.StatusRequest
-	11,  // 43: daemon.DaemonService.SubscribeStatus:input_type -> daemon.StatusRequest
-	13,  // 44: daemon.DaemonService.Down:input_type -> daemon.DownRequest
-	15,  // 45: daemon.DaemonService.GetConfig:input_type -> daemon.GetConfigRequest
-	26,  // 46: daemon.DaemonService.ListNetworks:input_type -> daemon.ListNetworksRequest
-	28,  // 47: daemon.DaemonService.SelectNetworks:input_type -> daemon.SelectNetworksRequest
-	28,  // 48: daemon.DaemonService.DeselectNetworks:input_type -> daemon.SelectNetworksRequest
-	4,   // 49: daemon.DaemonService.ForwardingRules:input_type -> daemon.EmptyRequest
-	35,  // 50: daemon.DaemonService.DebugBundle:input_type -> daemon.DebugBundleRequest
-	37,  // 51: daemon.DaemonService.GetLogLevel:input_type -> daemon.GetLogLevelRequest
-	39,  // 52: daemon.DaemonService.SetLogLevel:input_type -> daemon.SetLogLevelRequest
-	44,  // 53: daemon.DaemonService.ListStates:input_type -> daemon.ListStatesRequest
-	46,  // 54: daemon.DaemonService.CleanState:input_type -> daemon.CleanStateRequest
-	48,  // 55: daemon.DaemonService.DeleteState:input_type -> daemon.DeleteStateRequest
-	50,  // 56: daemon.DaemonService.SetSyncResponsePersistence:input_type -> daemon.SetSyncResponsePersistenceRequest
-	53,  // 57: daemon.DaemonService.TracePacket:input_type -> daemon.TracePacketRequest
-	105, // 58: daemon.DaemonService.StartCapture:input_type -> daemon.StartCaptureRequest
-	107, // 59: daemon.DaemonService.StartBundleCapture:input_type -> daemon.StartBundleCaptureRequest
-	109, // 60: daemon.DaemonService.StopBundleCapture:input_type -> daemon.StopBundleCaptureRequest
-	56,  // 61: daemon.DaemonService.SubscribeEvents:input_type -> daemon.SubscribeRequest
-	58,  // 62: daemon.DaemonService.GetEvents:input_type -> daemon.GetEventsRequest
-	41,  // 63: daemon.DaemonService.RegisterUILog:input_type -> daemon.RegisterUILogRequest
-	60,  // 64: daemon.DaemonService.SwitchProfile:input_type -> daemon.SwitchProfileRequest
-	62,  // 65: daemon.DaemonService.SetConfig:input_type -> daemon.SetConfigRequest
-	64,  // 66: daemon.DaemonService.AddProfile:input_type -> daemon.AddProfileRequest
-	66,  // 67: daemon.DaemonService.RenameProfile:input_type -> daemon.RenameProfileRequest
-	68,  // 68: daemon.DaemonService.RemoveProfile:input_type -> daemon.RemoveProfileRequest
-	70,  // 69: daemon.DaemonService.ListProfiles:input_type -> daemon.ListProfilesRequest
-	73,  // 70: daemon.DaemonService.GetActiveProfile:input_type -> daemon.GetActiveProfileRequest
-	75,  // 71: daemon.DaemonService.Logout:input_type -> daemon.LogoutRequest
-	79,  // 72: daemon.DaemonService.GetFeatures:input_type -> daemon.GetFeaturesRequest
-	82,  // 73: daemon.DaemonService.TriggerUpdate:input_type -> daemon.TriggerUpdateRequest
-	84,  // 74: daemon.DaemonService.GetPeerSSHHostKey:input_type -> daemon.GetPeerSSHHostKeyRequest
-	86,  // 75: daemon.DaemonService.RequestJWTAuth:input_type -> daemon.RequestJWTAuthRequest
-	88,  // 76: daemon.DaemonService.WaitJWTToken:input_type -> daemon.WaitJWTTokenRequest
-	90,  // 77: daemon.DaemonService.RequestExtendAuthSession:input_type -> daemon.RequestExtendAuthSessionRequest
-	92,  // 78: daemon.DaemonService.WaitExtendAuthSession:input_type -> daemon.WaitExtendAuthSessionRequest
-	94,  // 79: daemon.DaemonService.DismissSessionWarning:input_type -> daemon.DismissSessionWarningRequest
-	96,  // 80: daemon.DaemonService.StartCPUProfile:input_type -> daemon.StartCPUProfileRequest
-	98,  // 81: daemon.DaemonService.StopCPUProfile:input_type -> daemon.StopCPUProfileRequest
-	100, // 82: daemon.DaemonService.GetInstallerResult:input_type -> daemon.InstallerResultRequest
-	102, // 83: daemon.DaemonService.ExposeService:input_type -> daemon.ExposeServiceRequest
-	77,  // 84: daemon.DaemonService.WailsUIReady:input_type -> daemon.WailsUIReadyRequest
-	6,   // 85: daemon.DaemonService.Login:output_type -> daemon.LoginResponse
-	8,   // 86: daemon.DaemonService.WaitSSOLogin:output_type -> daemon.WaitSSOLoginResponse
-	10,  // 87: daemon.DaemonService.Up:output_type -> daemon.UpResponse
-	12,  // 88: daemon.DaemonService.Status:output_type -> daemon.StatusResponse
-	12,  // 89: daemon.DaemonService.SubscribeStatus:output_type -> daemon.StatusResponse
-	14,  // 90: daemon.DaemonService.Down:output_type -> daemon.DownResponse
-	16,  // 91: daemon.DaemonService.GetConfig:output_type -> daemon.GetConfigResponse
-	27,  // 92: daemon.DaemonService.ListNetworks:output_type -> daemon.ListNetworksResponse
-	29,  // 93: daemon.DaemonService.SelectNetworks:output_type -> daemon.SelectNetworksResponse
-	29,  // 94: daemon.DaemonService.DeselectNetworks:output_type -> daemon.SelectNetworksResponse
-	34,  // 95: daemon.DaemonService.ForwardingRules:output_type -> daemon.ForwardingRulesResponse
-	36,  // 96: daemon.DaemonService.DebugBundle:output_type -> daemon.DebugBundleResponse
-	38,  // 97: daemon.DaemonService.GetLogLevel:output_type -> daemon.GetLogLevelResponse
-	40,  // 98: daemon.DaemonService.SetLogLevel:output_type -> daemon.SetLogLevelResponse
-	45,  // 99: daemon.DaemonService.ListStates:output_type -> daemon.ListStatesResponse
-	47,  // 100: daemon.DaemonService.CleanState:output_type -> daemon.CleanStateResponse
-	49,  // 101: daemon.DaemonService.DeleteState:output_type -> daemon.DeleteStateResponse
-	51,  // 102: daemon.DaemonService.SetSyncResponsePersistence:output_type -> daemon.SetSyncResponsePersistenceResponse
-	55,  // 103: daemon.DaemonService.TracePacket:output_type -> daemon.TracePacketResponse
-	106, // 104: daemon.DaemonService.StartCapture:output_type -> daemon.CapturePacket
-	108, // 105: daemon.DaemonService.StartBundleCapture:output_type -> daemon.StartBundleCaptureResponse
-	110, // 106: daemon.DaemonService.StopBundleCapture:output_type -> daemon.StopBundleCaptureResponse
-	57,  // 107: daemon.DaemonService.SubscribeEvents:output_type -> daemon.SystemEvent
-	59,  // 108: daemon.DaemonService.GetEvents:output_type -> daemon.GetEventsResponse
-	42,  // 109: daemon.DaemonService.RegisterUILog:output_type -> daemon.RegisterUILogResponse
-	61,  // 110: daemon.DaemonService.SwitchProfile:output_type -> daemon.SwitchProfileResponse
-	63,  // 111: daemon.DaemonService.SetConfig:output_type -> daemon.SetConfigResponse
-	65,  // 112: daemon.DaemonService.AddProfile:output_type -> daemon.AddProfileResponse
-	67,  // 113: daemon.DaemonService.RenameProfile:output_type -> daemon.RenameProfileResponse
-	69,  // 114: daemon.DaemonService.RemoveProfile:output_type -> daemon.RemoveProfileResponse
-	71,  // 115: daemon.DaemonService.ListProfiles:output_type -> daemon.ListProfilesResponse
-	74,  // 116: daemon.DaemonService.GetActiveProfile:output_type -> daemon.GetActiveProfileResponse
-	76,  // 117: daemon.DaemonService.Logout:output_type -> daemon.LogoutResponse
-	80,  // 118: daemon.DaemonService.GetFeatures:output_type -> daemon.GetFeaturesResponse
-	83,  // 119: daemon.DaemonService.TriggerUpdate:output_type -> daemon.TriggerUpdateResponse
-	85,  // 120: daemon.DaemonService.GetPeerSSHHostKey:output_type -> daemon.GetPeerSSHHostKeyResponse
-	87,  // 121: daemon.DaemonService.RequestJWTAuth:output_type -> daemon.RequestJWTAuthResponse
-	89,  // 122: daemon.DaemonService.WaitJWTToken:output_type -> daemon.WaitJWTTokenResponse
-	91,  // 123: daemon.DaemonService.RequestExtendAuthSession:output_type -> daemon.RequestExtendAuthSessionResponse
-	93,  // 124: daemon.DaemonService.WaitExtendAuthSession:output_type -> daemon.WaitExtendAuthSessionResponse
-	95,  // 125: daemon.DaemonService.DismissSessionWarning:output_type -> daemon.DismissSessionWarningResponse
-	97,  // 126: daemon.DaemonService.StartCPUProfile:output_type -> daemon.StartCPUProfileResponse
-	99,  // 127: daemon.DaemonService.StopCPUProfile:output_type -> daemon.StopCPUProfileResponse
-	101, // 128: daemon.DaemonService.GetInstallerResult:output_type -> daemon.InstallerResultResponse
-	103, // 129: daemon.DaemonService.ExposeService:output_type -> daemon.ExposeServiceEvent
-	78,  // 130: daemon.DaemonService.WailsUIReady:output_type -> daemon.WailsUIReadyResponse
-	85,  // [85:131] is the sub-list for method output_type
-	39,  // [39:85] is the sub-list for method input_type
-	39,  // [39:39] is the sub-list for extension type_name
-	39,  // [39:39] is the sub-list for extension extendee
-	0,   // [0:39] is the sub-list for field type_name
+	117, // 36: daemon.StartCaptureRequest.duration:type_name -> google.protobuf.Duration
+	117, // 37: daemon.StartBundleCaptureRequest.timeout:type_name -> google.protobuf.Duration
+	113, // 38: daemon.GetAgentNetworkSetupResponse.providers:type_name -> daemon.AgentNetworkProvider
+	30,  // 39: daemon.Network.ResolvedIPsEntry.value:type_name -> daemon.IPList
+	5,   // 40: daemon.DaemonService.Login:input_type -> daemon.LoginRequest
+	7,   // 41: daemon.DaemonService.WaitSSOLogin:input_type -> daemon.WaitSSOLoginRequest
+	9,   // 42: daemon.DaemonService.Up:input_type -> daemon.UpRequest
+	11,  // 43: daemon.DaemonService.Status:input_type -> daemon.StatusRequest
+	11,  // 44: daemon.DaemonService.SubscribeStatus:input_type -> daemon.StatusRequest
+	13,  // 45: daemon.DaemonService.Down:input_type -> daemon.DownRequest
+	15,  // 46: daemon.DaemonService.GetConfig:input_type -> daemon.GetConfigRequest
+	26,  // 47: daemon.DaemonService.ListNetworks:input_type -> daemon.ListNetworksRequest
+	28,  // 48: daemon.DaemonService.SelectNetworks:input_type -> daemon.SelectNetworksRequest
+	28,  // 49: daemon.DaemonService.DeselectNetworks:input_type -> daemon.SelectNetworksRequest
+	4,   // 50: daemon.DaemonService.ForwardingRules:input_type -> daemon.EmptyRequest
+	35,  // 51: daemon.DaemonService.DebugBundle:input_type -> daemon.DebugBundleRequest
+	37,  // 52: daemon.DaemonService.GetLogLevel:input_type -> daemon.GetLogLevelRequest
+	39,  // 53: daemon.DaemonService.SetLogLevel:input_type -> daemon.SetLogLevelRequest
+	44,  // 54: daemon.DaemonService.ListStates:input_type -> daemon.ListStatesRequest
+	46,  // 55: daemon.DaemonService.CleanState:input_type -> daemon.CleanStateRequest
+	48,  // 56: daemon.DaemonService.DeleteState:input_type -> daemon.DeleteStateRequest
+	50,  // 57: daemon.DaemonService.SetSyncResponsePersistence:input_type -> daemon.SetSyncResponsePersistenceRequest
+	53,  // 58: daemon.DaemonService.TracePacket:input_type -> daemon.TracePacketRequest
+	105, // 59: daemon.DaemonService.StartCapture:input_type -> daemon.StartCaptureRequest
+	107, // 60: daemon.DaemonService.StartBundleCapture:input_type -> daemon.StartBundleCaptureRequest
+	109, // 61: daemon.DaemonService.StopBundleCapture:input_type -> daemon.StopBundleCaptureRequest
+	56,  // 62: daemon.DaemonService.SubscribeEvents:input_type -> daemon.SubscribeRequest
+	58,  // 63: daemon.DaemonService.GetEvents:input_type -> daemon.GetEventsRequest
+	41,  // 64: daemon.DaemonService.RegisterUILog:input_type -> daemon.RegisterUILogRequest
+	60,  // 65: daemon.DaemonService.SwitchProfile:input_type -> daemon.SwitchProfileRequest
+	62,  // 66: daemon.DaemonService.SetConfig:input_type -> daemon.SetConfigRequest
+	64,  // 67: daemon.DaemonService.AddProfile:input_type -> daemon.AddProfileRequest
+	66,  // 68: daemon.DaemonService.RenameProfile:input_type -> daemon.RenameProfileRequest
+	68,  // 69: daemon.DaemonService.RemoveProfile:input_type -> daemon.RemoveProfileRequest
+	70,  // 70: daemon.DaemonService.ListProfiles:input_type -> daemon.ListProfilesRequest
+	73,  // 71: daemon.DaemonService.GetActiveProfile:input_type -> daemon.GetActiveProfileRequest
+	75,  // 72: daemon.DaemonService.Logout:input_type -> daemon.LogoutRequest
+	79,  // 73: daemon.DaemonService.GetFeatures:input_type -> daemon.GetFeaturesRequest
+	82,  // 74: daemon.DaemonService.TriggerUpdate:input_type -> daemon.TriggerUpdateRequest
+	84,  // 75: daemon.DaemonService.GetPeerSSHHostKey:input_type -> daemon.GetPeerSSHHostKeyRequest
+	86,  // 76: daemon.DaemonService.RequestJWTAuth:input_type -> daemon.RequestJWTAuthRequest
+	88,  // 77: daemon.DaemonService.WaitJWTToken:input_type -> daemon.WaitJWTTokenRequest
+	90,  // 78: daemon.DaemonService.RequestExtendAuthSession:input_type -> daemon.RequestExtendAuthSessionRequest
+	92,  // 79: daemon.DaemonService.WaitExtendAuthSession:input_type -> daemon.WaitExtendAuthSessionRequest
+	94,  // 80: daemon.DaemonService.DismissSessionWarning:input_type -> daemon.DismissSessionWarningRequest
+	96,  // 81: daemon.DaemonService.StartCPUProfile:input_type -> daemon.StartCPUProfileRequest
+	98,  // 82: daemon.DaemonService.StopCPUProfile:input_type -> daemon.StopCPUProfileRequest
+	100, // 83: daemon.DaemonService.GetInstallerResult:input_type -> daemon.InstallerResultRequest
+	102, // 84: daemon.DaemonService.ExposeService:input_type -> daemon.ExposeServiceRequest
+	77,  // 85: daemon.DaemonService.WailsUIReady:input_type -> daemon.WailsUIReadyRequest
+	111, // 86: daemon.DaemonService.GetAgentNetworkSetup:input_type -> daemon.GetAgentNetworkSetupRequest
+	6,   // 87: daemon.DaemonService.Login:output_type -> daemon.LoginResponse
+	8,   // 88: daemon.DaemonService.WaitSSOLogin:output_type -> daemon.WaitSSOLoginResponse
+	10,  // 89: daemon.DaemonService.Up:output_type -> daemon.UpResponse
+	12,  // 90: daemon.DaemonService.Status:output_type -> daemon.StatusResponse
+	12,  // 91: daemon.DaemonService.SubscribeStatus:output_type -> daemon.StatusResponse
+	14,  // 92: daemon.DaemonService.Down:output_type -> daemon.DownResponse
+	16,  // 93: daemon.DaemonService.GetConfig:output_type -> daemon.GetConfigResponse
+	27,  // 94: daemon.DaemonService.ListNetworks:output_type -> daemon.ListNetworksResponse
+	29,  // 95: daemon.DaemonService.SelectNetworks:output_type -> daemon.SelectNetworksResponse
+	29,  // 96: daemon.DaemonService.DeselectNetworks:output_type -> daemon.SelectNetworksResponse
+	34,  // 97: daemon.DaemonService.ForwardingRules:output_type -> daemon.ForwardingRulesResponse
+	36,  // 98: daemon.DaemonService.DebugBundle:output_type -> daemon.DebugBundleResponse
+	38,  // 99: daemon.DaemonService.GetLogLevel:output_type -> daemon.GetLogLevelResponse
+	40,  // 100: daemon.DaemonService.SetLogLevel:output_type -> daemon.SetLogLevelResponse
+	45,  // 101: daemon.DaemonService.ListStates:output_type -> daemon.ListStatesResponse
+	47,  // 102: daemon.DaemonService.CleanState:output_type -> daemon.CleanStateResponse
+	49,  // 103: daemon.DaemonService.DeleteState:output_type -> daemon.DeleteStateResponse
+	51,  // 104: daemon.DaemonService.SetSyncResponsePersistence:output_type -> daemon.SetSyncResponsePersistenceResponse
+	55,  // 105: daemon.DaemonService.TracePacket:output_type -> daemon.TracePacketResponse
+	106, // 106: daemon.DaemonService.StartCapture:output_type -> daemon.CapturePacket
+	108, // 107: daemon.DaemonService.StartBundleCapture:output_type -> daemon.StartBundleCaptureResponse
+	110, // 108: daemon.DaemonService.StopBundleCapture:output_type -> daemon.StopBundleCaptureResponse
+	57,  // 109: daemon.DaemonService.SubscribeEvents:output_type -> daemon.SystemEvent
+	59,  // 110: daemon.DaemonService.GetEvents:output_type -> daemon.GetEventsResponse
+	42,  // 111: daemon.DaemonService.RegisterUILog:output_type -> daemon.RegisterUILogResponse
+	61,  // 112: daemon.DaemonService.SwitchProfile:output_type -> daemon.SwitchProfileResponse
+	63,  // 113: daemon.DaemonService.SetConfig:output_type -> daemon.SetConfigResponse
+	65,  // 114: daemon.DaemonService.AddProfile:output_type -> daemon.AddProfileResponse
+	67,  // 115: daemon.DaemonService.RenameProfile:output_type -> daemon.RenameProfileResponse
+	69,  // 116: daemon.DaemonService.RemoveProfile:output_type -> daemon.RemoveProfileResponse
+	71,  // 117: daemon.DaemonService.ListProfiles:output_type -> daemon.ListProfilesResponse
+	74,  // 118: daemon.DaemonService.GetActiveProfile:output_type -> daemon.GetActiveProfileResponse
+	76,  // 119: daemon.DaemonService.Logout:output_type -> daemon.LogoutResponse
+	80,  // 120: daemon.DaemonService.GetFeatures:output_type -> daemon.GetFeaturesResponse
+	83,  // 121: daemon.DaemonService.TriggerUpdate:output_type -> daemon.TriggerUpdateResponse
+	85,  // 122: daemon.DaemonService.GetPeerSSHHostKey:output_type -> daemon.GetPeerSSHHostKeyResponse
+	87,  // 123: daemon.DaemonService.RequestJWTAuth:output_type -> daemon.RequestJWTAuthResponse
+	89,  // 124: daemon.DaemonService.WaitJWTToken:output_type -> daemon.WaitJWTTokenResponse
+	91,  // 125: daemon.DaemonService.RequestExtendAuthSession:output_type -> daemon.RequestExtendAuthSessionResponse
+	93,  // 126: daemon.DaemonService.WaitExtendAuthSession:output_type -> daemon.WaitExtendAuthSessionResponse
+	95,  // 127: daemon.DaemonService.DismissSessionWarning:output_type -> daemon.DismissSessionWarningResponse
+	97,  // 128: daemon.DaemonService.StartCPUProfile:output_type -> daemon.StartCPUProfileResponse
+	99,  // 129: daemon.DaemonService.StopCPUProfile:output_type -> daemon.StopCPUProfileResponse
+	101, // 130: daemon.DaemonService.GetInstallerResult:output_type -> daemon.InstallerResultResponse
+	103, // 131: daemon.DaemonService.ExposeService:output_type -> daemon.ExposeServiceEvent
+	78,  // 132: daemon.DaemonService.WailsUIReady:output_type -> daemon.WailsUIReadyResponse
+	112, // 133: daemon.DaemonService.GetAgentNetworkSetup:output_type -> daemon.GetAgentNetworkSetupResponse
+	87,  // [87:134] is the sub-list for method output_type
+	40,  // [40:87] is the sub-list for method input_type
+	40,  // [40:40] is the sub-list for extension type_name
+	40,  // [40:40] is the sub-list for extension extendee
+	0,   // [0:40] is the sub-list for field type_name
 }
 
 func init() { file_daemon_proto_init() }
@@ -7947,7 +8153,7 @@ func file_daemon_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: unsafe.Slice(unsafe.StringData(file_daemon_proto_rawDesc), len(file_daemon_proto_rawDesc)),
 			NumEnums:      4,
-			NumMessages:   110,
+			NumMessages:   113,
 			NumExtensions: 0,
 			NumServices:   1,
 		},

client/proto/daemon.pb.gw.go

@@ -1123,6 +1123,30 @@ func local_request_DaemonService_WailsUIReady_0(ctx context.Context, marshaler r
 	return msg, metadata, err
 }
 
+func request_DaemonService_GetAgentNetworkSetup_0(ctx context.Context, marshaler runtime.Marshaler, client DaemonServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq GetAgentNetworkSetupRequest
+		metadata runtime.ServerMetadata
+	)
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	msg, err := client.GetAgentNetworkSetup(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_DaemonService_GetAgentNetworkSetup_0(ctx context.Context, marshaler runtime.Marshaler, server DaemonServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq GetAgentNetworkSetupRequest
+		metadata runtime.ServerMetadata
+	)
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	msg, err := server.GetAgentNetworkSetup(ctx, &protoReq)
+	return msg, metadata, err
+}
+
 // RegisterDaemonServiceHandlerServer registers the http handlers for service DaemonService to "mux".
 // UnaryRPC     :call DaemonServiceServer directly.
 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@@ -1997,6 +2021,26 @@ func RegisterDaemonServiceHandlerServer(ctx context.Context, mux *runtime.ServeM
 		}
 		forward_DaemonService_WailsUIReady_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 	})
+	mux.Handle(http.MethodPost, pattern_DaemonService_GetAgentNetworkSetup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/daemon.DaemonService/GetAgentNetworkSetup", runtime.WithHTTPPathPattern("/daemon.DaemonService/GetAgentNetworkSetup"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_DaemonService_GetAgentNetworkSetup_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_DaemonService_GetAgentNetworkSetup_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
 
 	return nil
 }
@@ -2819,6 +2863,23 @@ func RegisterDaemonServiceHandlerClient(ctx context.Context, mux *runtime.ServeM
 		}
 		forward_DaemonService_WailsUIReady_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 	})
+	mux.Handle(http.MethodPost, pattern_DaemonService_GetAgentNetworkSetup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/daemon.DaemonService/GetAgentNetworkSetup", runtime.WithHTTPPathPattern("/daemon.DaemonService/GetAgentNetworkSetup"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_DaemonService_GetAgentNetworkSetup_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_DaemonService_GetAgentNetworkSetup_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
 	return nil
 }
 
@@ -2869,6 +2930,7 @@ var (
 	pattern_DaemonService_GetInstallerResult_0         = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"daemon.DaemonService", "GetInstallerResult"}, ""))
 	pattern_DaemonService_ExposeService_0              = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"daemon.DaemonService", "ExposeService"}, ""))
 	pattern_DaemonService_WailsUIReady_0               = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"daemon.DaemonService", "WailsUIReady"}, ""))
+	pattern_DaemonService_GetAgentNetworkSetup_0       = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"daemon.DaemonService", "GetAgentNetworkSetup"}, ""))
 )
 
 var (
@@ -2918,4 +2980,5 @@ var (
 	forward_DaemonService_GetInstallerResult_0         = runtime.ForwardResponseMessage
 	forward_DaemonService_ExposeService_0              = runtime.ForwardResponseStream
 	forward_DaemonService_WailsUIReady_0               = runtime.ForwardResponseMessage
+	forward_DaemonService_GetAgentNetworkSetup_0       = runtime.ForwardResponseMessage
 )

client/proto/daemon.proto

@@ -156,6 +156,12 @@ service DaemonService {
   // only cares whether the daemon implements it: an Unimplemented response
   // means the daemon predates this UI and is too old to drive it.
   rpc WailsUIReady(WailsUIReadyRequest) returns (WailsUIReadyResponse) {}
+
+  // GetAgentNetworkSetup returns the Agent Network connection info this
+  // peer's groups authorize: proxy endpoint plus effective providers and
+  // models. The daemon relays the request to management over its existing
+  // peer connection, so unprivileged CLI callers get a caller-scoped answer.
+  rpc GetAgentNetworkSetup(GetAgentNetworkSetupRequest) returns (GetAgentNetworkSetupResponse) {}
 }
 
 
@@ -1050,3 +1056,31 @@ message StartBundleCaptureRequest {
 message StartBundleCaptureResponse {}
 message StopBundleCaptureRequest {}
 message StopBundleCaptureResponse {}
+
+message GetAgentNetworkSetupRequest {}
+
+message GetAgentNetworkSetupResponse {
+  // configured is false when the account has no Agent Network set up or
+  // this peer's groups authorize none of it.
+  bool configured = 1;
+  // endpoint is the account's proxy base URL, reachable over the NetBird
+  // tunnel only. Empty when configured is false.
+  string endpoint = 2;
+  repeated AgentNetworkProvider providers = 3;
+}
+
+message AgentNetworkProvider {
+  // name is the operator-assigned provider label, e.g. "Bedrock prod".
+  string name = 1;
+  // catalog_id names the provider type, e.g. "anthropic_api", "bedrock_api".
+  string catalog_id = 2;
+  // api_flavor is the request-body shape the provider speaks ("anthropic",
+  // "openai"); empty when the proxy dispatches it by URL path instead.
+  string api_flavor = 3;
+  // all_models_allowed is true when no model allowlist restricts this
+  // provider for the caller.
+  bool all_models_allowed = 4;
+  // models is the effective model allowlist (or the declared/catalog models
+  // when all_models_allowed is true).
+  repeated string models = 5;
+}

client/proto/daemon_grpc.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
 // - protoc-gen-go-grpc v1.6.1
-// - protoc             v6.33.1
+// - protoc             v7.34.1
 // source: daemon.proto
 
 package proto
@@ -65,6 +65,7 @@ const (
 	DaemonService_GetInstallerResult_FullMethodName         = "/daemon.DaemonService/GetInstallerResult"
 	DaemonService_ExposeService_FullMethodName              = "/daemon.DaemonService/ExposeService"
 	DaemonService_WailsUIReady_FullMethodName               = "/daemon.DaemonService/WailsUIReady"
+	DaemonService_GetAgentNetworkSetup_FullMethodName       = "/daemon.DaemonService/GetAgentNetworkSetup"
 )
 
 // DaemonServiceClient is the client API for DaemonService service.
@@ -171,6 +172,11 @@ type DaemonServiceClient interface {
 	// only cares whether the daemon implements it: an Unimplemented response
 	// means the daemon predates this UI and is too old to drive it.
 	WailsUIReady(ctx context.Context, in *WailsUIReadyRequest, opts ...grpc.CallOption) (*WailsUIReadyResponse, error)
+	// GetAgentNetworkSetup returns the Agent Network connection info this
+	// peer's groups authorize: proxy endpoint plus effective providers and
+	// models. The daemon relays the request to management over its existing
+	// peer connection, so unprivileged CLI callers get a caller-scoped answer.
+	GetAgentNetworkSetup(ctx context.Context, in *GetAgentNetworkSetupRequest, opts ...grpc.CallOption) (*GetAgentNetworkSetupResponse, error)
 }
 
 type daemonServiceClient struct {
@@ -677,6 +683,16 @@ func (c *daemonServiceClient) WailsUIReady(ctx context.Context, in *WailsUIReady
 	return out, nil
 }
 
+func (c *daemonServiceClient) GetAgentNetworkSetup(ctx context.Context, in *GetAgentNetworkSetupRequest, opts ...grpc.CallOption) (*GetAgentNetworkSetupResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(GetAgentNetworkSetupResponse)
+	err := c.cc.Invoke(ctx, DaemonService_GetAgentNetworkSetup_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // DaemonServiceServer is the server API for DaemonService service.
 // All implementations must embed UnimplementedDaemonServiceServer
 // for forward compatibility.
@@ -781,6 +797,11 @@ type DaemonServiceServer interface {
 	// only cares whether the daemon implements it: an Unimplemented response
 	// means the daemon predates this UI and is too old to drive it.
 	WailsUIReady(context.Context, *WailsUIReadyRequest) (*WailsUIReadyResponse, error)
+	// GetAgentNetworkSetup returns the Agent Network connection info this
+	// peer's groups authorize: proxy endpoint plus effective providers and
+	// models. The daemon relays the request to management over its existing
+	// peer connection, so unprivileged CLI callers get a caller-scoped answer.
+	GetAgentNetworkSetup(context.Context, *GetAgentNetworkSetupRequest) (*GetAgentNetworkSetupResponse, error)
 	mustEmbedUnimplementedDaemonServiceServer()
 }
 
@@ -929,6 +950,9 @@ func (UnimplementedDaemonServiceServer) ExposeService(*ExposeServiceRequest, grp
 func (UnimplementedDaemonServiceServer) WailsUIReady(context.Context, *WailsUIReadyRequest) (*WailsUIReadyResponse, error) {
 	return nil, status.Error(codes.Unimplemented, "method WailsUIReady not implemented")
 }
+func (UnimplementedDaemonServiceServer) GetAgentNetworkSetup(context.Context, *GetAgentNetworkSetupRequest) (*GetAgentNetworkSetupResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method GetAgentNetworkSetup not implemented")
+}
 func (UnimplementedDaemonServiceServer) mustEmbedUnimplementedDaemonServiceServer() {}
 func (UnimplementedDaemonServiceServer) testEmbeddedByValue()                       {}
 
@@ -1750,6 +1774,24 @@ func _DaemonService_WailsUIReady_Handler(srv interface{}, ctx context.Context, d
 	return interceptor(ctx, in, info, handler)
 }
 
+func _DaemonService_GetAgentNetworkSetup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetAgentNetworkSetupRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DaemonServiceServer).GetAgentNetworkSetup(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: DaemonService_GetAgentNetworkSetup_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DaemonServiceServer).GetAgentNetworkSetup(ctx, req.(*GetAgentNetworkSetupRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 // DaemonService_ServiceDesc is the grpc.ServiceDesc for DaemonService service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -1925,6 +1967,10 @@ var DaemonService_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "WailsUIReady",
 			Handler:    _DaemonService_WailsUIReady_Handler,
 		},
+		{
+			MethodName: "GetAgentNetworkSetup",
+			Handler:    _DaemonService_GetAgentNetworkSetup_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{

client/server/agentnetwork.go

@@ -0,0 +1,59 @@
+package server
+
+import (
+	"context"
+	"time"
+
+	"google.golang.org/grpc/codes"
+	gstatus "google.golang.org/grpc/status"
+
+	"github.com/netbirdio/netbird/client/proto"
+	mgmProto "github.com/netbirdio/netbird/shared/management/proto"
+)
+
+// GetAgentNetworkSetup relays the peer's Agent Network setup request to the
+// management server over the engine's existing connection. Running through
+// the daemon keeps the WireGuard key inside the daemon — unprivileged CLI
+// callers get a caller-scoped answer without reading the profile config.
+func (s *Server) GetAgentNetworkSetup(ctx context.Context, _ *proto.GetAgentNetworkSetupRequest) (*proto.GetAgentNetworkSetupResponse, error) {
+	s.mutex.Lock()
+	clientRunning := s.clientRunning
+	connectClient := s.connectClient
+	s.mutex.Unlock()
+
+	if !clientRunning || connectClient == nil {
+		return nil, gstatus.Errorf(codes.FailedPrecondition, "client is not running, run 'netbird up' first")
+	}
+	engine := connectClient.Engine()
+	if engine == nil {
+		return nil, gstatus.Errorf(codes.FailedPrecondition, "engine not initialized")
+	}
+
+	setupCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+
+	setup, err := engine.GetAgentNetworkSetup(setupCtx)
+	if err != nil {
+		return nil, gstatus.Errorf(codes.Internal, "get agent network setup: %v", err)
+	}
+
+	return toDaemonAgentNetworkSetup(setup), nil
+}
+
+func toDaemonAgentNetworkSetup(setup *mgmProto.AgentNetworkSetupResponse) *proto.GetAgentNetworkSetupResponse {
+	resp := &proto.GetAgentNetworkSetupResponse{
+		Configured: setup.Configured,
+		Endpoint:   setup.Endpoint,
+		Providers:  make([]*proto.AgentNetworkProvider, 0, len(setup.Providers)),
+	}
+	for _, p := range setup.Providers {
+		resp.Providers = append(resp.Providers, &proto.AgentNetworkProvider{
+			Name:             p.Name,
+			CatalogId:        p.CatalogId,
+			ApiFlavor:        p.ApiFlavor,
+			AllModelsAllowed: p.AllModelsAllowed,
+			Models:           p.Models,
+		})
+	}
+	return resp
+}

client/server/login_outcome_test.go

@@ -8,6 +8,8 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc/codes"
+	gstatus "google.golang.org/grpc/status"
 
 	"github.com/netbirdio/netbird/client/internal"
 	"github.com/netbirdio/netbird/client/proto"
@@ -25,9 +27,9 @@ func TestLogin_ManagementUnreachableIsReturnedInsteadOfDemandingSSO(t *testing.T
 
 	unreachable := errors.New("create connection: dial context: context deadline exceeded")
 	attempts := 0
-	s.isLoginRequiredFn = func(context.Context) (bool, error) {
+	s.loginAttemptFn = func(context.Context, string, string) (internal.StatusType, error) {
 		attempts++
-		return false, unreachable
+		return internal.StatusLoginFailed, unreachable
 	}
 
 	resp, err := s.Login(userCtx(), &proto.LoginRequest{Username: &username})
@@ -53,12 +55,15 @@ func TestLogin_AuthRefusalStartsSSOFlow(t *testing.T) {
 	s.rootCtx = internal.CtxInitState(context.Background())
 	breakProfilePrivateKey(t, cfgPath)
 
-	s.isLoginRequiredFn = func(context.Context) (bool, error) {
-		return true, nil
+	refused := gstatus.Error(codes.PermissionDenied, "peer is not registered")
+	s.loginAttemptFn = func(context.Context, string, string) (internal.StatusType, error) {
+		return internal.StatusNeedsLogin, refused
 	}
 
 	_, err := s.Login(userCtx(), &proto.LoginRequest{Username: &username})
 	require.Error(t, err)
+	require.NotErrorIs(t, err, refused,
+		"the refusal was handed back to the caller instead of starting the SSO flow")
 
 	status, stateErr := internal.CtxGetState(s.rootCtx).Status()
 	require.NoError(t, stateErr)
@@ -66,32 +71,6 @@ func TestLogin_AuthRefusalStartsSSOFlow(t *testing.T) {
 		"the SSO flow setup was never reached with the broken key")
 }
 
-func TestLogin_SetupKeyStillRunsWhenPeerNeedsLogin(t *testing.T) {
-	s, _, _, username, _ := setupServerWithProfile(t)
-	s.rootCtx = internal.CtxInitState(context.Background())
-
-	s.isLoginRequiredFn = func(context.Context) (bool, error) {
-		return true, nil
-	}
-
-	var keysTried []string
-	s.loginAttemptFn = func(_ context.Context, setupKey, _ string) (internal.StatusType, error) {
-		keysTried = append(keysTried, setupKey)
-		return "", nil
-	}
-
-	setupKey := "A2C8E32F-AEB2-4B45-8FD3-8A0C1B2D3E4F"
-	resp, err := s.Login(userCtx(), &proto.LoginRequest{Username: &username, SetupKey: setupKey})
-	require.NoError(t, err, "the probe's outcome leaked out as the login result")
-	require.NotNil(t, resp)
-	require.Equal(t, []string{setupKey}, keysTried, "the setup key never reached the login attempt")
-	require.Nil(t, s.oauthAuthFlow.flow, "a setup-key login started an SSO flow")
-
-	status, err := internal.CtxGetState(s.rootCtx).Status()
-	require.NoError(t, err)
-	require.Equal(t, internal.StatusIdle, status)
-}
-
 // breakProfilePrivateKey replaces the profile's private key with an unparseable
 // one, which makes any attempt to build a Management client fail on the spot.
 func breakProfilePrivateKey(t *testing.T, cfgPath string) {

client/server/server.go

@@ -140,8 +140,6 @@ type Server struct {
 	// it to drive the login outcomes that need a server on the other end;
 	// production leaves it nil, and every login goes through loginAttempt.
 	loginAttemptFn func(ctx context.Context, setupKey, jwtToken string) (internal.StatusType, error)
-
-	isLoginRequiredFn func(ctx context.Context) (bool, error)
 }
 
 type oauthAuthFlow struct {
@@ -386,21 +384,6 @@ func (s *Server) attemptLogin(ctx context.Context, setupKey, jwtToken string) (i
 	return s.loginAttempt(ctx, setupKey, jwtToken)
 }
 
-func (s *Server) isLoginRequired(ctx context.Context) (bool, error) {
-	if s.isLoginRequiredFn != nil {
-		return s.isLoginRequiredFn(ctx)
-	}
-
-	authClient, err := auth.NewAuth(ctx, s.config.PrivateKey, s.config.ManagementURL, s.config)
-	if err != nil {
-		log.Errorf("failed to create auth client: %v", err)
-		return false, err
-	}
-	defer authClient.Close()
-
-	return authClient.IsLoginRequired(ctx)
-}
-
 // loginAttempt attempts to login using the provided information. It returns
 // StatusNeedsLogin when Management refused the peer's credentials and
 // StatusLoginFailed for every other failure, so callers can tell an
@@ -657,22 +640,22 @@ func (s *Server) Login(callerCtx context.Context, msg *proto.LoginRequest) (*pro
 	s.config = config
 	s.mutex.Unlock()
 
-	// A probe that errors leaves the login undecided: Management unreachable, a
+	loginStatus, err := s.attemptLogin(ctx, "", "")
+	if err == nil {
+		state.Set(internal.StatusIdle)
+		return &proto.LoginResponse{}, nil
+	}
+
+	// Only an authentication refusal means the peer has to (re-)authenticate.
+	// Any other failure leaves the login undecided: Management unreachable, a
 	// restart mid-request, an internal error. Those are returned for the caller
 	// to retry, because turning them into an SSO prompt asks the user to solve
 	// something that is not theirs to solve, and a browser login cannot succeed
-	// while Management is unreachable anyway. Only Management refusing the
-	// peer's key is a decision, and IsLoginRequired reports that as
-	// needsLogin=true rather than an error.
-	needsLogin, err := s.isLoginRequired(ctx)
-	if err != nil {
-		state.Set(internal.StatusLoginFailed)
+	// while Management is unreachable anyway.
+	if loginStatus != internal.StatusNeedsLogin {
+		state.Set(loginStatus)
 		return nil, err
 	}
-	if !needsLogin {
-		state.Set(internal.StatusIdle)
-		return &proto.LoginResponse{}, nil
-	}
 
 	if msg.SetupKey == "" {
 		hint := ""
@@ -1815,9 +1798,6 @@ func (s *Server) RequestExtendAuthSession(
 	if connectClient == nil {
 		return nil, gstatus.Errorf(codes.FailedPrecondition, "client is not running")
 	}
-	if connectClient.Engine() == nil {
-		return nil, gstatus.Errorf(codes.FailedPrecondition, "session can no longer be extended, log in again to reconnect")
-	}
 
 	hint := ""
 	if msg.Hint != nil {

client/ui/build/linux/netbird-ui.desktop

@@ -1,11 +1,10 @@
 [Desktop Entry]
 Type=Application
-Name=NetBird
-Comment=NetBird desktop client
+Name=netbird-ui
 Exec=env WEBKIT_DISABLE_DMABUF_RENDERER=1 netbird-ui
 Icon=netbird-ui
-Categories=Utility;Network;
+Categories=Development;
 Terminal=false
-Keywords=netbird;vpn;wireguard;
+Keywords=wails
 Version=1.0
 StartupNotify=false

client/ui/build/linux/netbird.desktop

@@ -1,6 +1,5 @@
 [Desktop Entry]
-Name=NetBird
-Comment=NetBird desktop client
+Name=Netbird
 Exec=env WEBKIT_DISABLE_DMABUF_RENDERER=1 /usr/bin/netbird-ui
 Icon=netbird
 Type=Application

client/ui/build/linux/nfpm/nfpm.yaml

@@ -21,17 +21,8 @@ contents:
     dst: "/usr/local/bin/netbird-ui"
   - src: "./build/appicon.png"
     dst: "/usr/share/icons/hicolor/128x128/apps/netbird-ui.png"
-  # The name the polkit action's icon_name refers to, which the released packages
-  # install as /usr/share/pixmaps/netbird.png.
-  - src: "./build/appicon.png"
-    dst: "/usr/share/icons/hicolor/128x128/apps/netbird.png"
   - src: "./build/linux/netbird-ui.desktop"
     dst: "/usr/share/applications/netbird-ui.desktop"
-  # Names the polkit action for the elevation prompt the app raises when an
-  # unprivileged user changes a privileged setting; without it the dialog shows a
-  # raw command line.
-  - src: "./build/linux/polkit/io.netbird.settings.policy"
-    dst: "/usr/share/polkit-1/actions/io.netbird.settings.policy"
 
 # Default dependencies for the GTK4 + WebKitGTK 6.0 stack (Ubuntu 24.04+ / Debian 13+)
 depends:

client/ui/build/linux/polkit/io.netbird.settings.policy

@@ -1,47 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE policyconfig PUBLIC "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
- "http://www.freedesktop.org/standards/PolicyKit/1/policyconfig.dtd">
-
-<!--
-  Names the action behind the elevation prompt the desktop app raises for an SSH
-  setting the daemon restricts to root; without it pkexec's generic dialog offers
-  the raw command line instead. The argv1 annotation keeps this wording to the
-  one-shot mode that applies those settings.
-
-  auth_admin rather than auth_admin_keep: each of these settings is its own grant
-  of shell access, so a credential cache would let a second, unasked-for change
-  ride along on the authorization given the first.
-
-  exec.path takes no wildcard and the binary's location depends on the package,
-  hence one action per path.
--->
-<policyconfig>
-  <vendor>NetBird</vendor>
-  <vendor_url>https://netbird.io</vendor_url>
-
-  <action id="io.netbird.settings.apply-privileged">
-    <description>Change privileged NetBird settings</description>
-    <message>Authentication is required to change NetBird settings that grant SSH access to this computer.</message>
-    <icon_name>netbird</icon_name>
-    <defaults>
-      <allow_any>auth_admin</allow_any>
-      <allow_inactive>auth_admin</allow_inactive>
-      <allow_active>auth_admin</allow_active>
-    </defaults>
-    <annotate key="org.freedesktop.policykit.exec.path">/usr/bin/netbird-ui</annotate>
-    <annotate key="org.freedesktop.policykit.exec.argv1">--apply-privileged-settings</annotate>
-  </action>
-
-  <action id="io.netbird.settings.apply-privileged-local">
-    <description>Change privileged NetBird settings</description>
-    <message>Authentication is required to change NetBird settings that grant SSH access to this computer.</message>
-    <icon_name>netbird</icon_name>
-    <defaults>
-      <allow_any>auth_admin</allow_any>
-      <allow_inactive>auth_admin</allow_inactive>
-      <allow_active>auth_admin</allow_active>
-    </defaults>
-    <annotate key="org.freedesktop.policykit.exec.path">/usr/local/bin/netbird-ui</annotate>
-    <annotate key="org.freedesktop.policykit.exec.argv1">--apply-privileged-settings</annotate>
-  </action>
-</policyconfig>

client/ui/frontend/src/contexts/SettingsContext.tsx

@@ -22,18 +22,12 @@ const logSaveError = (err: unknown) => console.error("[SettingsContext] save fai
 
 export type AutostartState = { supported: boolean; enabled: boolean };
 
-// GuardedField is a setting the daemon only accepts from root/administrator.
-// Turning one on goes through saveGuardedField, which asks the operating system
-// for the privileges rather than sending a request that would be refused.
-export type GuardedField = "serverSshAllowed" | "enableSshRoot" | "disableSshAuth";
-
 type SettingsContextValue = {
     config: Config;
     guiVersion: string;
     setField: <K extends keyof Config>(k: K, v: Config[K]) => void;
     saveField: <K extends keyof Config>(k: K, v: Config[K]) => Promise<void>;
     saveFields: (partial: Partial<Config>, opts?: { preSharedKey?: string }) => Promise<void>;
-    saveGuardedField: (k: GuardedField, v: boolean) => Promise<void>;
     saveNow: () => Promise<void>;
 };
 
@@ -69,12 +63,6 @@ const useSettingsState = () => {
     const [guiVersion, setGuiVersion] = useState<string>("—");
     const saveTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
     const loadedRef = useRef<LoadedConfig | null>(null);
-    // Set when the daemon's config changed while a save was pending, so the read
-    // that was skipped to protect the pending edit happens once it is through.
-    // Without it the form keeps values the daemon no longer has and the next save
-    // submits them, which for a guarded setting means asking the user to authorize
-    // a change they never made.
-    const reloadOwed = useRef(false);
 
     useEffect(() => {
         loadedRef.current = loaded;
@@ -85,7 +73,6 @@ const useSettingsState = () => {
     // update the daemon then rejected.
     const reload = useCallback(
         async (profileName: string) => {
-            reloadOwed.current = false;
             try {
                 const data = await SettingsSvc.GetConfig({ profileName, username });
                 setLoaded({ profileName, data });
@@ -107,12 +94,7 @@ const useSettingsState = () => {
                     username,
                 });
                 if (cancelled) return;
-                // A pending edit outranks the daemon's copy until it is saved, so
-                // the read is owed rather than dropped: see reloadOwed.
-                if (saveTimer.current) {
-                    reloadOwed.current = true;
-                    return;
-                }
+                if (saveTimer.current) return;
                 setLoaded({ profileName: activeProfileId, data });
             } catch (e) {
                 if (cancelled || !showError) return;
@@ -159,17 +141,12 @@ const useSettingsState = () => {
         async (profileName: string, next: Config, preSharedKey?: string) => {
             const preSharedKeyWrite = preSharedKey === undefined ? {} : { preSharedKey };
             try {
-                const { declined } = await SettingsSvc.SetConfig({
+                await SettingsSvc.SetConfig({
                     ...next,
                     ...preSharedKeyWrite,
                     profileName,
                     username,
                 });
-                // The change needed authorization and the user said no, so the
-                // optimistic update is wrong. Nothing to report: they know.
-                if (declined || reloadOwed.current) {
-                    await reload(profileName);
-                }
             } catch (e) {
                 // The optimistic update is wrong now: the daemon refused it
                 // (a change that needs elevated privileges, an MDM-managed
@@ -229,59 +206,6 @@ const useSettingsState = () => {
         [loaded, save],
     );
 
-    // saveGuardedField applies a setting the daemon restricts to
-    // root/administrator by having the Go side run the app again under the
-    // platform's elevation prompt (UAC, the macOS authentication dialog, polkit).
-    // The prompt is the user's, so the call is made straight from their gesture
-    // and never from the debounce.
-    const saveGuardedField = useCallback(
-        async (k: GuardedField, v: boolean) => {
-            const cur = loadedRef.current;
-            if (!cur) return;
-
-            // Flush what the debounce still owes, before the optimistic update
-            // below joins it: a later save carrying the guarded value would be
-            // refused, and its error dialog would be the second one for a change
-            // the user already authorized.
-            if (saveTimer.current) {
-                clearTimeout(saveTimer.current);
-                saveTimer.current = null;
-                await save(cur.profileName, cur.data);
-            }
-
-            const next: LoadedConfig = {
-                profileName: cur.profileName,
-                data: { ...cur.data, [k]: v },
-            };
-            loadedRef.current = next;
-            setLoaded(next);
-
-            try {
-                await SettingsSvc.SetGuardedSettings({
-                    profileName: cur.profileName,
-                    username,
-                    [k]: v,
-                });
-            } catch (e) {
-                // The daemon is authoritative either way, so re-read before
-                // reporting. A declined prompt is not an error and does not come
-                // through here at all; this is a prompt that could not be raised,
-                // which carries the command that would have done it.
-                await reload(cur.profileName);
-                await errorDialog({
-                    Title: i18next.t("settings.error.saveTitle"),
-                    Message: errorMessage(e),
-                    Command: errorCommand(e),
-                });
-                return;
-            }
-            // Either the change went through or the user declined it. The daemon
-            // says which.
-            await reload(cur.profileName);
-        },
-        [username, save, reload],
-    );
-
     const saveFields = useCallback(
         async (partial: Partial<Config>, opts?: { preSharedKey?: string }) => {
             if (!loaded) return;
@@ -301,27 +225,15 @@ const useSettingsState = () => {
         [loaded, save],
     );
 
-    return {
-        config: loaded?.data ?? null,
-        guiVersion,
-        setField,
-        saveField,
-        saveFields,
-        saveGuardedField,
-        saveNow,
-    };
+    return { config: loaded?.data ?? null, guiVersion, setField, saveField, saveFields, saveNow };
 };
 
 export const SettingsProvider = ({ children }: { children: ReactNode }) => {
-    const { config, guiVersion, setField, saveField, saveFields, saveGuardedField, saveNow } =
-        useSettingsState();
+    const { config, guiVersion, setField, saveField, saveFields, saveNow } = useSettingsState();
 
     const value = useMemo<SettingsContextValue | null>(
-        () =>
-            config
-                ? { config, guiVersion, setField, saveField, saveFields, saveGuardedField, saveNow }
-                : null,
-        [config, guiVersion, setField, saveField, saveFields, saveGuardedField, saveNow],
+        () => (config ? { config, guiVersion, setField, saveField, saveFields, saveNow } : null),
+        [config, guiVersion, setField, saveField, saveFields, saveNow],
     );
 
     if (!value) {

client/ui/frontend/src/hooks/usePrivilege.ts

@@ -1,6 +1,6 @@
 import { useEffect, useState } from "react";
 import { Settings as SettingsSvc } from "@bindings/services";
-import { type Privilege } from "@bindings/services/models.js";
+import { Privilege } from "@bindings/services/models.js";
 
 // usePrivilege reports whether this UI process may perform the changes the daemon
 // restricts to root/administrator. It is answered in-process from our own token

client/ui/frontend/src/modules/session/SessionExpirationDialog.tsx

@@ -11,7 +11,7 @@ import { DialogHeading } from "@/components/dialog/DialogHeading";
 import { SquareIcon } from "@/components/SquareIcon";
 import { Connection, Profiles as ProfilesSvc, Session, WindowManager } from "@bindings/services";
 import { useAutoSizeWindow } from "@/hooks/useAutoSizeWindow";
-import { EVENT_BROWSER_LOGIN_CANCEL, EVENT_TRIGGER_LOGIN } from "@/lib/connection";
+import { EVENT_BROWSER_LOGIN_CANCEL } from "@/lib/connection";
 import { errorDialog, formatErrorMessage } from "@/lib/errors.ts";
 import { formatRemaining } from "@/lib/formatters";
 
@@ -131,21 +131,6 @@ export default function SessionExpirationDialog() {
         }
     }, [busy, t]);
 
-    const authenticate = useCallback(async () => {
-        if (busy) return;
-        setBusy(true);
-        try {
-            await Events.Emit(EVENT_TRIGGER_LOGIN);
-            await WindowManager.CloseSessionExpiration();
-        } catch (e) {
-            setBusy(false);
-            await errorDialog({
-                Title: t("connect.error.loginTitle"),
-                Message: formatErrorMessage(e),
-            });
-        }
-    }, [busy, t]);
-
     const logout = useCallback(async () => {
         if (busy) return;
         setBusy(true);
@@ -200,7 +185,7 @@ export default function SessionExpirationDialog() {
                     variant={"primary"}
                     size={"md"}
                     className={"w-full"}
-                    onClick={expired ? authenticate : stay}
+                    onClick={stay}
                     disabled={busy}
                 >
                     {expired ? t("sessionExpiration.authenticate") : t("sessionExpiration.stay")}

client/ui/frontend/src/modules/settings/SettingsSSH.tsx

@@ -1,4 +1,3 @@
-import { type TFunction } from "i18next";
 import { useTranslation } from "react-i18next";
 import { CopyToClipboard } from "@/components/CopyToClipboard";
 import FancyToggleSwitch from "@/components/switches/FancyToggleSwitch";
@@ -7,91 +6,51 @@ import { Input } from "@/components/inputs/Input";
 import { Label } from "@/components/typography/Label";
 import { cn } from "@/lib/cn";
 import { SectionGroup } from "@/modules/settings/SettingsSection.tsx";
-import { type GuardedField, useSettings } from "@/contexts/SettingsContext.tsx";
+import { useSettings } from "@/contexts/SettingsContext.tsx";
 import { usePrivilege } from "@/hooks/usePrivilege.ts";
-import type { Privilege } from "@bindings/services/models.js";
+import { Privilege } from "@bindings/services/models.js";
 import { type ChangeEvent, type ReactNode, useEffect, useId, useState } from "react";
 
 export function SettingsSSH() {
     const { t } = useTranslation();
-    const { config, setField, saveGuardedField } = useSettings();
+    const { config, setField } = useSettings();
     const privilege = usePrivilege();
-    // The field whose elevation prompt is currently up, if any. The prompt is
-    // modal to the operating system, not to us, so the guarded controls are held
-    // still meanwhile rather than allowed to stack a second one behind it.
-    const [authorizing, setAuthorizing] = useState<GuardedField | null>(null);
     const isSSHServerEnabled = config.serverSshAllowed;
 
-    const authorize = async (field: GuardedField, value: boolean) => {
-        setAuthorizing(field);
-        try {
-            await saveGuardedField(field, value);
-        } finally {
-            setAuthorizing(null);
-        }
-    };
-
     // The daemon restricts only the direction that hands out shells from a process
-    // running as root: for all three settings that is switching the field on.
-    //
-    // An unprivileged user gets that direction routed through the platform's
-    // elevation prompt where there is one to raise, and otherwise the old
-    // arrangement, where the control is either unavailable (it is off and only a
-    // privileged caller could turn it on) or a one-way switch (it is on, they may
-    // turn it off but not back on) with the command that does it.
+    // running as root. So for an unprivileged user a guarded control is either
+    // unavailable (it is off and only they could turn it on) or a one-way switch
+    // (it is on, they may turn it off, but not back on) — say which, either way.
     //
     // A null privilege means we could not determine it: leave the control alone
     // rather than greying it out with nothing to explain why. The daemon enforces
     // this regardless, and a rejected save reports its own guidance.
     const guarded = (
-        field: GuardedField,
+        guardedDirectionActive: boolean,
         command: (p: Privilege) => string,
         // inverted marks a control whose guarded direction is switching it off, so
         // the one-way warning has to read the other way round.
         inverted = false,
     ) => {
-        const plain = (value: boolean) => setField(field, value);
         if (!privilege || privilege.privileged) {
-            return { apply: plain, disabled: false, hint: undefined };
+            return { disabled: false, hint: undefined };
         }
-
-        const guardedDirectionActive = config[field];
-        const hint = (pending: boolean, command?: string) => (
-            <GuardedHint
-                actor={actorLabel(privilege, t)}
+        const hint = (
+            <PrivilegeHint
+                actor={privilege.actor}
+                command={command(privilege)}
                 oneWay={guardedDirectionActive}
                 inverted={inverted}
-                pending={pending}
-                command={command}
             />
         );
-
-        if (privilege.canElevate) {
-            return {
-                // Switching off is ours to do; only switching on is authorized.
-                apply: (value: boolean) => {
-                    if (!value) {
-                        plain(value);
-                        return;
-                    }
-                    void authorize(field, value);
-                },
-                disabled: authorizing !== null,
-                hint: hint(authorizing === field),
-            };
-        }
-        return {
-            apply: plain,
-            disabled: !guardedDirectionActive,
-            hint: hint(false, command(privilege)),
-        };
+        return { disabled: !guardedDirectionActive, hint };
     };
 
-    const sshServer = guarded("serverSshAllowed", (p) => p.allowSshServer);
-    const sshRoot = guarded("enableSshRoot", (p) => p.enableSshRoot);
+    const sshServer = guarded(config.serverSshAllowed, (p) => p.allowSshServer);
+    const sshRoot = guarded(config.enableSshRoot, (p) => p.enableSshRoot);
     // Inverted control: the guarded direction is switching authentication off, so
     // it is the already-disabled state that is the one-way one.
-    const sshAuth = guarded("disableSshAuth", (p) => p.disableSshAuth, true);
+    const sshAuth = guarded(config.disableSshAuth, (p) => p.disableSshAuth, true);
     const jwtTtlId = useId();
     const [jwtTtlInput, setJwtTtlInput] = useState(String(config.sshJwtCacheTtl));
 
@@ -125,7 +84,7 @@ export function SettingsSSH() {
             <SectionGroup title={t("settings.ssh.section.server")}>
                 <FancyToggleSwitch
                     value={config.serverSshAllowed}
-                    onChange={sshServer.apply}
+                    onChange={(v) => setField("serverSshAllowed", v)}
                     disabled={sshServer.disabled}
                     label={t("settings.ssh.server.label")}
                     helpText={t("settings.ssh.server.help")}
@@ -139,7 +98,7 @@ export function SettingsSSH() {
             >
                 <FancyToggleSwitch
                     value={config.enableSshRoot}
-                    onChange={sshRoot.apply}
+                    onChange={(v) => setField("enableSshRoot", v)}
                     disabled={sshRoot.disabled}
                     label={t("settings.ssh.root.label")}
                     helpText={t("settings.ssh.root.help")}
@@ -171,7 +130,7 @@ export function SettingsSSH() {
             >
                 <FancyToggleSwitch
                     value={!config.disableSshAuth}
-                    onChange={(v) => sshAuth.apply(!v)}
+                    onChange={(v) => setField("disableSshAuth", !v)}
                     disabled={sshAuth.disabled}
                     label={t("settings.ssh.jwt.label")}
                     helpText={t("settings.ssh.jwt.help")}
@@ -204,81 +163,41 @@ export function SettingsSSH() {
     );
 }
 
-// actorLabel names the principal the daemon requires, in the user's language. The
-// Go side reports which one it is rather than wording it, because "administrator
-// privileges" is English and a translated sentence cannot borrow it.
-function actorLabel(privilege: Privilege, t: TFunction): string {
-    return privilege.actorKey === "administrator"
-        ? t("settings.ssh.privilege.actorAdministrator")
-        : t("settings.ssh.privilege.actorRoot");
-}
-
-// GuardedHint is what a control the daemon guards says to an unprivileged user.
-// There are three things worth saying, and it says at most one:
-//
-//   - A prompt is open. Worth a line because it can take a few seconds to appear,
-//     long enough that a control which merely went inert would read as a hang.
-//   - The setting is in its guarded state already (oneWay), so the user may switch
-//     it back as they please and it is switching it away again that will ask. No
-//     command either way: the direction they can take is theirs to take.
-//   - Only a privileged caller can move it at all, and there is no prompt to
-//     raise: the command that does it belongs here, and nothing else will do.
-//
-// Which leaves the case of a control whose guarded direction is still ahead of the
-// user and a prompt that can be raised for it: nothing to say, because clicking it
-// raises the prompt and the prompt explains itself.
-function GuardedHint({
+// PrivilegeHint explains what an unprivileged user can and cannot do with a
+// guarded control, and offers the command that does it with the privileges the
+// daemon requires. oneWay covers the control being in the guarded state already:
+// switching it back is the part that needs privileges.
+function PrivilegeHint({
     actor,
+    command,
     oneWay,
     inverted,
-    pending,
-    command,
 }: {
     actor: string;
+    command: string;
     oneWay: boolean;
     inverted: boolean;
-    pending: boolean;
-    command?: string;
 }): ReactNode {
     const { t } = useTranslation();
-
-    if (pending) {
-        return <HintBox>{t("settings.ssh.privilege.authorizePending")}</HintBox>;
-    }
-    if (oneWay) {
-        return (
-            <HintBox>
-                <span>
-                    {inverted
-                        ? t("settings.ssh.privilege.oneWayInverted", { actor })
-                        : t("settings.ssh.privilege.oneWay", { actor })}
-                </span>
-            </HintBox>
-        );
-    }
     if (!command) return null;
-    return (
-        <HintBox>
-            <span>{t("settings.ssh.privilege.hint", { actor })}</span>
-            <CopyToClipboard message={command} alwaysShowIcon wrap variant={"bright"}>
-                <code className={"select-text break-all font-mono text-xs text-nb-gray-200"}>
-                    {command}
-                </code>
-            </CopyToClipboard>
-        </HintBox>
-    );
-}
-
-// HintBox is the box a guarded control puts its explanation in, directly under the
-// control it belongs to.
-function HintBox({ children }: { children: ReactNode }): ReactNode {
     return (
         <div
             className={
                 "-mt-2 flex flex-col gap-1 rounded-md bg-nb-gray-930 px-3 py-2 text-xs text-nb-gray-300"
             }
         >
-            {children}
+            <span>
+                {!oneWay
+                    ? t("settings.ssh.privilege.hint", { actor })
+                    : inverted
+                      ? t("settings.ssh.privilege.oneWayInverted", { actor })
+                      : t("settings.ssh.privilege.oneWay", { actor })}
+            </span>
+            <CopyToClipboard message={command} alwaysShowIcon wrap variant={"bright"}>
+                <code className={"select-text break-all font-mono text-xs text-nb-gray-200"}>
+                    {command}
+                </code>
+            </CopyToClipboard>
         </div>
     );
 }

client/ui/i18n/locales/de/common.json

@@ -401,6 +401,9 @@
     "networks.bulk.label": {
         "message": "Alle sichtbaren Ressourcen umschalten"
     },
+    "settings.nav.label": {
+        "message": "Einstellungsbereiche"
+    },
     "profile.switch.title": {
         "message": "Zu Profil \"{name}\" wechseln?"
     },
@@ -494,9 +497,6 @@
     "settings.error.debugBundleTitle": {
         "message": "Debug-Paket fehlgeschlagen"
     },
-    "settings.nav.label": {
-        "message": "Einstellungsbereiche"
-    },
     "settings.tabs.general": {
         "message": "Allgemein"
     },
@@ -1330,29 +1330,5 @@
     },
     "error.unknown": {
         "message": "Vorgang fehlgeschlagen."
-    },
-    "error.elevation_unavailable": {
-        "message": "NetBird konnte auf diesem System nicht die nötigen Rechte anfordern. Führen Sie stattdessen dies aus:"
-    },
-    "error.elevation_failed": {
-        "message": "Die Änderung konnte mit erhöhten Rechten nicht angewendet werden. Führen Sie stattdessen dies aus:"
-    },
-    "settings.ssh.privilege.actorRoot": {
-        "message": "root-Rechte"
-    },
-    "settings.ssh.privilege.actorAdministrator": {
-        "message": "Administratorrechte"
-    },
-    "settings.ssh.privilege.hint": {
-        "message": "Erfordert {actor}. Führen Sie stattdessen dies aus:"
-    },
-    "settings.ssh.privilege.oneWay": {
-        "message": "Sie können dies deaktivieren, zum erneuten Aktivieren sind {actor} erforderlich."
-    },
-    "settings.ssh.privilege.oneWayInverted": {
-        "message": "Sie können dies aktivieren, zum erneuten Deaktivieren sind {actor} erforderlich."
-    },
-    "settings.ssh.privilege.authorizePending": {
-        "message": "Warten auf Autorisierung…"
     }
 }

client/ui/i18n/locales/en/common.json

@@ -1775,36 +1775,16 @@
         "message": "Operation failed.",
         "description": "Generic fallback error message used when no specific error applies."
     },
-    "error.elevation_unavailable": {
-        "message": "NetBird could not ask this system for the privileges the change needs. Run this instead:",
-        "description": "Error: this computer has no way to prompt for elevated privileges. Followed by a copyable command that applies the setting from a terminal."
-    },
-    "error.elevation_failed": {
-        "message": "The change could not be applied with elevated privileges. Run this instead:",
-        "description": "Error: the authorization succeeded but applying the setting afterwards failed. Followed by a copyable command that applies the setting from a terminal."
-    },
-    "settings.ssh.privilege.actorRoot": {
-        "message": "root",
-        "description": "Fills {actor} in the settings.ssh.privilege.* messages on Linux, macOS and BSD, where the daemon requires the root account. 'root' is an account name and stays as it is; add the word for privileges or rights around it if the sentence needs one to read naturally."
-    },
-    "settings.ssh.privilege.actorAdministrator": {
-        "message": "administrator privileges",
-        "description": "Fills {actor} in the settings.ssh.privilege.* messages on Windows, where the daemon requires an elevated administrator. The Windows term for the rights an account is asked to elevate to."
-    },
     "settings.ssh.privilege.hint": {
         "message": "Requires {actor}. Run this instead:",
         "description": "Help text under an SSH setting the user cannot change: it needs elevated privileges. {actor} is 'root' on Linux/macOS or 'administrator privileges' on Windows. Followed by a copyable command."
     },
     "settings.ssh.privilege.oneWay": {
-        "message": "You can switch this off, but switching it back on needs {actor}.",
-        "description": "Help text under an SSH setting that is already on: an unprivileged user may switch it off freely, and switching it on again is what needs the privileges. No command follows, since the direction they can take is theirs to take. {actor} is 'root' on Linux/macOS or 'administrator privileges' on Windows."
+        "message": "You can switch this off, but switching it back on needs {actor}:",
+        "description": "Warning under an SSH setting an unprivileged user may disable but not re-enable. {actor} is 'root' on Linux/macOS or 'administrator privileges' on Windows. Followed by a copyable command."
     },
     "settings.ssh.privilege.oneWayInverted": {
-        "message": "You can switch this on, but switching it back off needs {actor}.",
-        "description": "Same as settings.ssh.privilege.oneWay, for the SSH authentication setting once it has been switched off: switching it off again is what needs the privileges."
-    },
-    "settings.ssh.privilege.authorizePending": {
-        "message": "Waiting for authorization…",
-        "description": "Replaces the help text under a guarded SSH setting while the authorization prompt is open, which can take a few seconds to appear. Keep the trailing ellipsis."
+        "message": "You can switch this on, but switching it back off needs {actor}:",
+        "description": "Warning under the SSH authentication setting, which an unprivileged user may re-enable but not disable again. {actor} is 'root' on Linux/macOS or 'administrator privileges' on Windows. Followed by a copyable command."
     }
 }

client/ui/i18n/locales/es/common.json

@@ -401,6 +401,9 @@
     "networks.bulk.label": {
         "message": "Conmutar todos los recursos visibles"
     },
+    "settings.nav.label": {
+        "message": "Secciones de configuración"
+    },
     "profile.switch.title": {
         "message": "¿Cambiar el perfil a «{name}»?"
     },
@@ -494,9 +497,6 @@
     "settings.error.debugBundleTitle": {
         "message": "Error en el paquete de diagnóstico"
     },
-    "settings.nav.label": {
-        "message": "Secciones de configuración"
-    },
     "settings.tabs.general": {
         "message": "General"
     },
@@ -1330,29 +1330,5 @@
     },
     "error.unknown": {
         "message": "La operación falló."
-    },
-    "error.elevation_unavailable": {
-        "message": "NetBird no pudo solicitar a este sistema los privilegios necesarios. Ejecute esto en su lugar:"
-    },
-    "error.elevation_failed": {
-        "message": "No se pudo aplicar el cambio con privilegios elevados. Ejecute esto en su lugar:"
-    },
-    "settings.ssh.privilege.actorRoot": {
-        "message": "privilegios de root"
-    },
-    "settings.ssh.privilege.actorAdministrator": {
-        "message": "privilegios de administrador"
-    },
-    "settings.ssh.privilege.hint": {
-        "message": "Requiere {actor}. Ejecute esto en su lugar:"
-    },
-    "settings.ssh.privilege.oneWay": {
-        "message": "Puede desactivarlo, pero volver a activarlo requiere {actor}."
-    },
-    "settings.ssh.privilege.oneWayInverted": {
-        "message": "Puede activarlo, pero volver a desactivarlo requiere {actor}."
-    },
-    "settings.ssh.privilege.authorizePending": {
-        "message": "Esperando la autorización…"
     }
 }

client/ui/i18n/locales/fr/common.json

@@ -401,6 +401,9 @@
     "networks.bulk.label": {
         "message": "Activer/désactiver toutes les ressources visibles"
     },
+    "settings.nav.label": {
+        "message": "Sections des paramètres"
+    },
     "profile.switch.title": {
         "message": "Basculer vers le profil « {name} » ?"
     },
@@ -494,9 +497,6 @@
     "settings.error.debugBundleTitle": {
         "message": "Échec du lot de diagnostic"
     },
-    "settings.nav.label": {
-        "message": "Sections des paramètres"
-    },
     "settings.tabs.general": {
         "message": "Général"
     },
@@ -1330,29 +1330,5 @@
     },
     "error.unknown": {
         "message": "L’opération a échoué."
-    },
-    "error.elevation_unavailable": {
-        "message": "NetBird n’a pas pu demander à ce système les privilèges nécessaires. Exécutez plutôt ceci :"
-    },
-    "error.elevation_failed": {
-        "message": "La modification n’a pas pu être appliquée avec des privilèges élevés. Exécutez plutôt ceci :"
-    },
-    "settings.ssh.privilege.actorRoot": {
-        "message": "les privilèges root"
-    },
-    "settings.ssh.privilege.actorAdministrator": {
-        "message": "les privilèges administrateur"
-    },
-    "settings.ssh.privilege.hint": {
-        "message": "Nécessite {actor}. Exécutez plutôt ceci :"
-    },
-    "settings.ssh.privilege.oneWay": {
-        "message": "Vous pouvez le désactiver, mais le réactiver nécessite {actor}."
-    },
-    "settings.ssh.privilege.oneWayInverted": {
-        "message": "Vous pouvez l’activer, mais le désactiver de nouveau nécessite {actor}."
-    },
-    "settings.ssh.privilege.authorizePending": {
-        "message": "En attente de l’autorisation…"
     }
 }

client/ui/i18n/locales/hu/common.json

@@ -401,6 +401,9 @@
     "networks.bulk.label": {
         "message": "Összes látható erőforrás be/ki"
     },
+    "settings.nav.label": {
+        "message": "Beállítások szakaszai"
+    },
     "profile.switch.title": {
         "message": "Váltás a(z) \"{name}\" profilra?"
     },
@@ -494,9 +497,6 @@
     "settings.error.debugBundleTitle": {
         "message": "Hibakeresési csomag sikertelen"
     },
-    "settings.nav.label": {
-        "message": "Beállítások szakaszai"
-    },
     "settings.tabs.general": {
         "message": "Általános"
     },
@@ -1330,29 +1330,5 @@
     },
     "error.unknown": {
         "message": "A művelet meghiúsult."
-    },
-    "error.elevation_unavailable": {
-        "message": "A NetBird nem tudta bekérni a rendszertől a szükséges jogosultságokat. Futtassa inkább ezt:"
-    },
-    "error.elevation_failed": {
-        "message": "A módosítást emelt szintű jogosultságokkal sem sikerült alkalmazni. Futtassa inkább ezt:"
-    },
-    "settings.ssh.privilege.actorRoot": {
-        "message": "root jogosultság"
-    },
-    "settings.ssh.privilege.actorAdministrator": {
-        "message": "rendszergazdai jogosultság"
-    },
-    "settings.ssh.privilege.hint": {
-        "message": "{actor} szükséges hozzá. Futtassa inkább ezt:"
-    },
-    "settings.ssh.privilege.oneWay": {
-        "message": "Kikapcsolhatja, de a visszakapcsolásához {actor} szükséges."
-    },
-    "settings.ssh.privilege.oneWayInverted": {
-        "message": "Bekapcsolhatja, de az ismételt kikapcsolásához {actor} szükséges."
-    },
-    "settings.ssh.privilege.authorizePending": {
-        "message": "Várakozás az engedélyezésre…"
     }
 }

client/ui/i18n/locales/it/common.json

@@ -401,6 +401,9 @@
     "networks.bulk.label": {
         "message": "Attiva/disattiva tutte le risorse visibili"
     },
+    "settings.nav.label": {
+        "message": "Sezioni delle impostazioni"
+    },
     "profile.switch.title": {
         "message": "Passare al profilo «{name}»?"
     },
@@ -494,9 +497,6 @@
     "settings.error.debugBundleTitle": {
         "message": "Pacchetto di debug non riuscito"
     },
-    "settings.nav.label": {
-        "message": "Sezioni delle impostazioni"
-    },
     "settings.tabs.general": {
         "message": "Generale"
     },
@@ -1330,29 +1330,5 @@
     },
     "error.unknown": {
         "message": "Operazione non riuscita."
-    },
-    "error.elevation_unavailable": {
-        "message": "NetBird non ha potuto richiedere a questo sistema i privilegi necessari. Esegua invece questo:"
-    },
-    "error.elevation_failed": {
-        "message": "Non è stato possibile applicare la modifica con privilegi elevati. Esegua invece questo:"
-    },
-    "settings.ssh.privilege.actorRoot": {
-        "message": "i privilegi di root"
-    },
-    "settings.ssh.privilege.actorAdministrator": {
-        "message": "i privilegi di amministratore"
-    },
-    "settings.ssh.privilege.hint": {
-        "message": "Richiede {actor}. Esegua invece questo:"
-    },
-    "settings.ssh.privilege.oneWay": {
-        "message": "Può disabilitarlo, ma riabilitarlo richiede {actor}."
-    },
-    "settings.ssh.privilege.oneWayInverted": {
-        "message": "Può abilitarlo, ma disabilitarlo di nuovo richiede {actor}."
-    },
-    "settings.ssh.privilege.authorizePending": {
-        "message": "In attesa dell'autorizzazione…"
     }
 }

client/ui/i18n/locales/ja/common.json

@@ -1304,9 +1304,6 @@
     "daemon.outdated.description": {
         "message": "このアプリを使用するには NetBird サービスを更新してください。"
     },
-    "daemon.outdated.download": {
-        "message": "最新版をダウンロード"
-    },
     "error.jwt_clock_skew": {
         "message": "サインインに失敗しました: このデバイスの時計がサーバーと同期していません。システムの時計を同期してからもう一度お試しください。"
     },
@@ -1330,29 +1327,5 @@
     },
     "error.unknown": {
         "message": "操作に失敗しました。"
-    },
-    "error.elevation_unavailable": {
-        "message": "NetBird はこのシステムに必要な権限を要求できませんでした。代わりに次のコマンドを実行してください:"
-    },
-    "error.elevation_failed": {
-        "message": "昇格した権限でも変更を適用できませんでした。代わりに次のコマンドを実行してください:"
-    },
-    "settings.ssh.privilege.actorRoot": {
-        "message": "root 権限"
-    },
-    "settings.ssh.privilege.actorAdministrator": {
-        "message": "管理者権限"
-    },
-    "settings.ssh.privilege.hint": {
-        "message": "{actor}が必要です。代わりに次のコマンドを実行してください:"
-    },
-    "settings.ssh.privilege.oneWay": {
-        "message": "無効にはできますが、再度有効にするには{actor}が必要です。"
-    },
-    "settings.ssh.privilege.oneWayInverted": {
-        "message": "有効にはできますが、再度無効にするには{actor}が必要です。"
-    },
-    "settings.ssh.privilege.authorizePending": {
-        "message": "承認を待っています…"
     }
 }

client/ui/i18n/locales/pt/common.json

@@ -401,6 +401,9 @@
     "networks.bulk.label": {
         "message": "Alternar todos os recursos visíveis"
     },
+    "settings.nav.label": {
+        "message": "Seções das configurações"
+    },
     "profile.switch.title": {
         "message": "Alternar perfil para \"{name}\"?"
     },
@@ -494,9 +497,6 @@
     "settings.error.debugBundleTitle": {
         "message": "Falha no pacote de depuração"
     },
-    "settings.nav.label": {
-        "message": "Seções das configurações"
-    },
     "settings.tabs.general": {
         "message": "Geral"
     },
@@ -1330,29 +1330,5 @@
     },
     "error.unknown": {
         "message": "A operação falhou."
-    },
-    "error.elevation_unavailable": {
-        "message": "O NetBird não conseguiu solicitar a este sistema os privilégios necessários. Execute isto em vez disso:"
-    },
-    "error.elevation_failed": {
-        "message": "Não foi possível aplicar a alteração com privilégios elevados. Execute isto em vez disso:"
-    },
-    "settings.ssh.privilege.actorRoot": {
-        "message": "privilégios de root"
-    },
-    "settings.ssh.privilege.actorAdministrator": {
-        "message": "privilégios de administrador"
-    },
-    "settings.ssh.privilege.hint": {
-        "message": "Requer {actor}. Execute isto em vez disso:"
-    },
-    "settings.ssh.privilege.oneWay": {
-        "message": "Você pode desativar isto, mas ativar novamente requer {actor}."
-    },
-    "settings.ssh.privilege.oneWayInverted": {
-        "message": "Você pode ativar isto, mas desativar novamente requer {actor}."
-    },
-    "settings.ssh.privilege.authorizePending": {
-        "message": "Aguardando a autorização…"
     }
 }

client/ui/i18n/locales/ru/common.json

@@ -401,6 +401,9 @@
     "networks.bulk.label": {
         "message": "Переключить все видимые ресурсы"
     },
+    "settings.nav.label": {
+        "message": "Разделы настроек"
+    },
     "profile.switch.title": {
         "message": "Переключиться на профиль «{name}»?"
     },
@@ -494,9 +497,6 @@
     "settings.error.debugBundleTitle": {
         "message": "Не удалось создать отладочный пакет"
     },
-    "settings.nav.label": {
-        "message": "Разделы настроек"
-    },
     "settings.tabs.general": {
         "message": "Общие"
     },
@@ -1330,29 +1330,5 @@
     },
     "error.unknown": {
         "message": "Не удалось выполнить операцию."
-    },
-    "error.elevation_unavailable": {
-        "message": "NetBird не смог запросить у этой системы нужные права. Выполните вместо этого:"
-    },
-    "error.elevation_failed": {
-        "message": "Не удалось применить изменение с повышенными правами. Выполните вместо этого:"
-    },
-    "settings.ssh.privilege.actorRoot": {
-        "message": "права root"
-    },
-    "settings.ssh.privilege.actorAdministrator": {
-        "message": "права администратора"
-    },
-    "settings.ssh.privilege.hint": {
-        "message": "Требуются {actor}. Выполните вместо этого:"
-    },
-    "settings.ssh.privilege.oneWay": {
-        "message": "Отключить можно, но чтобы включить снова, нужны {actor}."
-    },
-    "settings.ssh.privilege.oneWayInverted": {
-        "message": "Включить можно, но чтобы отключить снова, нужны {actor}."
-    },
-    "settings.ssh.privilege.authorizePending": {
-        "message": "Ожидание авторизации…"
     }
 }

client/ui/i18n/locales/zh-CN/common.json

@@ -401,6 +401,9 @@
     "networks.bulk.label": {
         "message": "切换所有可见资源"
     },
+    "settings.nav.label": {
+        "message": "设置部分"
+    },
     "profile.switch.title": {
         "message": "切换到配置文件“{name}”？"
     },
@@ -494,9 +497,6 @@
     "settings.error.debugBundleTitle": {
         "message": "创建调试包失败"
     },
-    "settings.nav.label": {
-        "message": "设置部分"
-    },
     "settings.tabs.general": {
         "message": "常规"
     },
@@ -1330,29 +1330,5 @@
     },
     "error.unknown": {
         "message": "操作失败。"
-    },
-    "error.elevation_unavailable": {
-        "message": "NetBird 无法向此系统请求所需的权限。请改为运行："
-    },
-    "error.elevation_failed": {
-        "message": "即使使用提升的权限也无法应用此更改。请改为运行："
-    },
-    "settings.ssh.privilege.actorRoot": {
-        "message": "root 权限"
-    },
-    "settings.ssh.privilege.actorAdministrator": {
-        "message": "管理员权限"
-    },
-    "settings.ssh.privilege.hint": {
-        "message": "需要{actor}。请改为运行："
-    },
-    "settings.ssh.privilege.oneWay": {
-        "message": "您可以关闭此项，但重新开启需要{actor}。"
-    },
-    "settings.ssh.privilege.oneWayInverted": {
-        "message": "您可以开启此项，但再次关闭需要{actor}。"
-    },
-    "settings.ssh.privilege.authorizePending": {
-        "message": "正在等待授权…"
     }
 }

client/ui/main.go

@@ -8,7 +8,6 @@ import (
 	"flag"
 	"io/fs"
 	"log"
-	"os"
 	"runtime"
 	"strings"
 
@@ -80,14 +79,6 @@ func init() {
 }
 
 func main() {
-	// The one-shot that applies the settings the daemon restricts to
-	// root/administrator, which this binary runs itself as under the platform's
-	// elevation prompt. Handled before anything GUI so no window, tray or
-	// single-instance lock is involved.
-	if services.IsPrivilegedSettingsRun(os.Args[1:]) {
-		os.Exit(runPrivilegedSettings(os.Args[1:]))
-	}
-
 	daemonAddr, userSetLogFile := parseFlagsAndInitLog()
 	conn := NewConn(daemonAddr)
 

client/ui/privileged_settings.go

@@ -1,27 +0,0 @@
-//go:build !android && !ios && !freebsd && !js
-
-package main
-
-import (
-	"github.com/netbirdio/netbird/client/proto"
-	"github.com/netbirdio/netbird/client/ui/services"
-)
-
-// The one-shot mode this binary runs itself in, elevated, to apply the settings the
-// daemon restricts to root/administrator. It is handled before anything GUI, so no
-// window, tray or single-instance lock is involved.
-//
-// Only the wiring is here: what the mode accepts and does lives beside the code
-// that asks for it, in services.RunPrivilegedSettings, so the settings it will
-// apply are declared once. There is nothing privileged about the mode itself; it
-// sends the same request the frontend would have sent, and the daemon authorizes it
-// from the identity the kernel reports on the control channel exactly as it does
-// for `sudo netbird up`.
-func runPrivilegedSettings(args []string) int {
-	return services.RunPrivilegedSettings(args, func(addr string) (proto.DaemonServiceClient, error) {
-		if addr == "" {
-			addr = DaemonAddr()
-		}
-		return NewConn(addr).Client()
-	})
-}

client/ui/services/guarded.go

@@ -1,226 +0,0 @@
-//go:build !android && !ios && !freebsd && !js
-
-package services
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-	"time"
-
-	log "github.com/sirupsen/logrus"
-
-	"github.com/netbirdio/netbird/client/internal/elevate"
-	"github.com/netbirdio/netbird/client/internal/ipcauth"
-)
-
-// The command line of the one-shot mode this binary runs itself in, elevated, to
-// apply a setting the daemon restricts to root/administrator. The setting flags
-// spell the same words as `netbird up`, so the command a user is shown and what
-// runs behind the prompt read alike. Parsed in oneshot.go.
-const (
-	FlagApplyPrivilegedSettings = "apply-privileged-settings"
-	FlagDaemonAddr              = "daemon-addr"
-	FlagProfile                 = "profile"
-	FlagUser                    = "user"
-	FlagLogLevel                = "log-level"
-	FlagManagementURL           = "management-url"
-	FlagAllowServerSSH          = "allow-server-ssh"
-	FlagEnableSSHRoot           = "enable-ssh-root"
-	FlagDisableSSHAuth          = "disable-ssh-auth"
-)
-
-// Error codes for the ways asking for privileges can fail.
-const (
-	CodeElevationUnavailable = "elevation_unavailable"
-	CodeElevationFailed      = "elevation_failed"
-)
-
-// elevationTimeout bounds the wait for a prompt and the change behind it, so a
-// dialog nobody answers does not leave its control disabled for the session. Long
-// enough to find a password manager, and no shorter than the platforms' own prompt
-// timeouts: Windows gives up on its consent dialog after two minutes by itself.
-//
-// It always ends our waiting, and not always the prompt: Security.framework offers
-// no way to withdraw a request, so on macOS the system's own timeout is what closes
-// the dialog.
-const elevationTimeout = 5 * time.Minute
-
-// elevator raises the platform's privilege prompt and runs the change behind it.
-// An interface so tests can answer without a prompt.
-type elevator interface {
-	// Run runs this binary again, elevated, with the given arguments.
-	Run(ctx context.Context, args ...string) error
-	// Available reports whether there is a prompt to raise on this host at all.
-	Available() bool
-}
-
-// osElevator is the real thing: see the elevate package.
-type osElevator struct{}
-
-func (osElevator) Run(ctx context.Context, args ...string) error {
-	return elevate.Run(ctx, args...)
-}
-
-func (osElevator) Available() bool {
-	return elevate.Available()
-}
-
-// SaveOutcome reports what became of a change that needed authorization.
-//
-// A declined prompt is a result, not an error: the user was asked and said no, so
-// nothing was applied and nothing went wrong. Reporting it as an error would have
-// every cancelled prompt logged as one.
-type SaveOutcome struct {
-	// Declined is set when the user dismissed the authorization prompt, or was
-	// refused by policy. Nothing was changed.
-	Declined bool `json:"declined"`
-}
-
-// GuardedSettings is the subset of the config the daemon restricts to
-// root/administrator. Only the fields that are set are changed: a nil pointer, or
-// an empty management URL, leaves that setting alone.
-//
-// The management URL is in here because pointing a host with the SSH server
-// running at another management identity hands the decision of who may open a
-// shell on it to whoever runs that server, which is the same power as enabling
-// the SSH server in the first place.
-type GuardedSettings struct {
-	ProfileName      string `json:"profileName"`
-	Username         string `json:"username"`
-	ManagementURL    string `json:"managementUrl,omitempty"`
-	ServerSSHAllowed *bool  `json:"serverSshAllowed,omitempty"`
-	EnableSSHRoot    *bool  `json:"enableSshRoot,omitempty"`
-	DisableSSHAuth   *bool  `json:"disableSshAuth,omitempty"`
-}
-
-// guardedSetting is one setting to change, in the two spellings this needs: the
-// one-shot's own flag, and the `netbird up` flag that does the same thing from a
-// terminal, for when there is no prompt to raise.
-type guardedSetting struct {
-	arg  string
-	flag string
-}
-
-// SetGuardedSettings applies settings the daemon refuses from an unprivileged
-// caller, by having the operating system run this binary again, elevated, to send
-// the same request the frontend would have sent itself.
-//
-// The user authorizes it at the platform's own prompt: the UAC consent dialog,
-// the macOS authentication dialog, or the polkit agent's. Any credentials are the
-// operating system's business; NetBird neither sees nor asks for them. Nothing
-// about the daemon's rules changes, and the elevated process is authorized like
-// any other privileged caller, from the identity the kernel reports for it.
-//
-// A declined prompt comes back as SaveOutcome.Declined with no error. When there is
-// no prompt to raise, or the elevated run failed, the error carries the command
-// that does the same thing from a terminal.
-func (s *Settings) SetGuardedSettings(ctx context.Context, p GuardedSettings) (SaveOutcome, error) {
-	settings := guardedSettings(p)
-	if len(settings) == 0 {
-		return SaveOutcome{}, &ClientError{
-			Code:  CodeElevationFailed,
-			Short: "no setting to apply",
-			Long:  "no setting to apply",
-		}
-	}
-
-	args := append([]string{
-		"--" + FlagApplyPrivilegedSettings,
-		"--" + FlagDaemonAddr, s.daemonAddr,
-		"--" + FlagProfile, p.ProfileName,
-		"--" + FlagUser, p.Username,
-	}, oneShotArgs(settings)...)
-
-	ctx, cancel := context.WithTimeout(ctx, elevationTimeout)
-	defer cancel()
-
-	// These changes hand out shells on this host, so both ends are logged: when the
-	// prompt went up, and what came of it. It is also the only account of a prompt
-	// that was slow to appear or never answered.
-	log.Infof("asking for privileges to apply %s", guardedSummary(p))
-
-	if err := s.elevator.Run(ctx, args...); err != nil {
-		return s.elevationOutcome(err, p)
-	}
-
-	log.Infof("applied %s with the privileges the user authorized", guardedSummary(p))
-	return SaveOutcome{}, nil
-}
-
-// elevationOutcome sorts what came back into the one normal ending and the two
-// that need reporting, with the command that does the same thing by hand.
-func (s *Settings) elevationOutcome(err error, p GuardedSettings) (SaveOutcome, error) {
-	switch {
-	case errors.Is(err, elevate.ErrDeclined):
-		// With the reason: an account that may not elevate at all lands here too,
-		// and the log is the only place that says which it was.
-		log.Infof("the elevation prompt for %s was declined: %v", guardedSummary(p), err)
-		return SaveOutcome{Declined: true}, nil
-	case errors.Is(err, elevate.ErrUnavailable):
-		log.Warnf("cannot ask for privileges to apply %s: %v", guardedSummary(p), err)
-		return SaveOutcome{}, &ClientError{
-			Code:    CodeElevationUnavailable,
-			Short:   s.classifier.translateShort(CodeElevationUnavailable),
-			Long:    err.Error(),
-			Command: guardedCommand(p),
-		}
-	default:
-		log.Errorf("applying %s with elevated privileges failed: %v", guardedSummary(p), err)
-		return SaveOutcome{}, &ClientError{
-			Code:    CodeElevationFailed,
-			Short:   s.classifier.translateShort(CodeElevationFailed),
-			Long:    err.Error(),
-			Command: guardedCommand(p),
-		}
-	}
-}
-
-// guardedSettings renders the settings that are actually being changed, from the
-// same table the one-shot parses them with: see oneshot.go.
-func guardedSettings(p GuardedSettings) []guardedSetting {
-	var settings []guardedSetting
-	for _, field := range guardedFields {
-		value, ok := field.read(p)
-		if !ok {
-			continue
-		}
-		settings = append(settings, guardedSetting{
-			arg:  "--" + field.flag + "=" + value,
-			flag: field.up(value),
-		})
-	}
-	return settings
-}
-
-func oneShotArgs(settings []guardedSetting) []string {
-	args := make([]string, 0, len(settings))
-	for _, setting := range settings {
-		args = append(args, setting.arg)
-	}
-	return args
-}
-
-func upFlags(settings []guardedSetting) []string {
-	flags := make([]string, 0, len(settings))
-	for _, setting := range settings {
-		flags = append(flags, setting.flag)
-	}
-	return flags
-}
-
-// guardedCommand is the elevated command line equivalent to the requested
-// change, the same shape the daemon names in its own refusals.
-func guardedCommand(p GuardedSettings) string {
-	settings := guardedSettings(p)
-	if len(settings) == 0 {
-		return ""
-	}
-	return ipcauth.UpCommand(strings.Join(upFlags(settings), " "))
-}
-
-// guardedSummary names the change for the log.
-func guardedSummary(p GuardedSettings) string {
-	return fmt.Sprintf("%v for profile %q", oneShotArgs(guardedSettings(p)), p.ProfileName)
-}

client/ui/services/guarded_test.go

@@ -1,349 +0,0 @@
-//go:build !android && !ios && !freebsd && !js
-
-package services
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"google.golang.org/genproto/googleapis/rpc/errdetails"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/codes"
-	gstatus "google.golang.org/grpc/status"
-
-	"github.com/netbirdio/netbird/client/internal/elevate"
-	"github.com/netbirdio/netbird/client/internal/ipcauth"
-	"github.com/netbirdio/netbird/client/proto"
-)
-
-// A Unix socket, so the daemon address is one that carries a caller's identity and
-// elevation is worth offering at all: see Settings.canElevate.
-const testDaemonAddr = "unix:///var/run/netbird.sock"
-
-// storedManagementURL is what the stub daemon already holds, so that a request
-// naming a different one is a change: see Settings.guardedChanges.
-const storedManagementURL = "https://stored.example.com"
-
-// stubElevator stands in for the platform's prompt: it records what would have run
-// and answers with a fixed outcome.
-type stubElevator struct {
-	outcome   error
-	available bool
-	calls     [][]string
-}
-
-func (e *stubElevator) Run(_ context.Context, args ...string) error {
-	e.calls = append(e.calls, args)
-	return e.outcome
-}
-
-func (e *stubElevator) Available() bool { return e.available }
-
-// stubDaemon implements only the RPCs under test. The embedded interface is nil, so
-// any other call panics rather than passing quietly.
-type stubDaemon struct {
-	proto.DaemonServiceClient
-	setConfig func(*proto.SetConfigRequest) error
-	// stored is what GetConfig reports, which is what a refused request's guarded
-	// settings are compared against.
-	stored   *proto.GetConfigResponse
-	requests []*proto.SetConfigRequest
-}
-
-func (d *stubDaemon) SetConfig(_ context.Context, in *proto.SetConfigRequest, _ ...grpc.CallOption) (*proto.SetConfigResponse, error) {
-	d.requests = append(d.requests, in)
-	if err := d.setConfig(in); err != nil {
-		return nil, err
-	}
-	return &proto.SetConfigResponse{}, nil
-}
-
-func (d *stubDaemon) GetConfig(_ context.Context, _ *proto.GetConfigRequest, _ ...grpc.CallOption) (*proto.GetConfigResponse, error) {
-	return d.stored, nil
-}
-
-type stubConn struct{ client proto.DaemonServiceClient }
-
-func (c stubConn) Client() (proto.DaemonServiceClient, error) { return c.client, nil }
-
-// privilegeRefusal is the error the daemon raises for a change it restricts to
-// root, detail and all: see server.privilegeError.
-func privilegeRefusal(t *testing.T) error {
-	t.Helper()
-
-	st, err := gstatus.New(codes.PermissionDenied, "Changing the management URL requires root.").
-		WithDetails(&errdetails.ErrorInfo{
-			Reason: ipcauth.ErrorReasonPrivilegeRequired,
-			Domain: ipcauth.ErrorDomain,
-			Metadata: map[string]string{
-				ipcauth.ErrorMetaSummary: "Changing the management URL requires root.",
-				ipcauth.ErrorMetaCommand: "sudo netbird down; sudo netbird up -m https://mgmt.example.com",
-			},
-		})
-	require.NoError(t, err, "build the refusal detail")
-	return st.Err()
-}
-
-func settingsWithElevation(t *testing.T, outcome error) (*Settings, *stubElevator) {
-	t.Helper()
-
-	elev := &stubElevator{outcome: outcome, available: true}
-	return &Settings{daemonAddr: testDaemonAddr, elevator: elev}, elev
-}
-
-// settingsRefusingOnce returns a Settings whose daemon refuses the first SetConfig
-// for want of privileges and accepts anything after it. Its stored config holds
-// another management server and no SSH grants, so a request naming either is a
-// change rather than a restatement.
-func settingsRefusingOnce(t *testing.T, elev *stubElevator) (*Settings, *stubDaemon) {
-	t.Helper()
-
-	refusal := privilegeRefusal(t)
-	daemon := &stubDaemon{stored: &proto.GetConfigResponse{ManagementUrl: storedManagementURL}}
-	daemon.setConfig = func(*proto.SetConfigRequest) error {
-		if len(daemon.requests) == 1 {
-			return refusal
-		}
-		return nil
-	}
-	return &Settings{conn: stubConn{client: daemon}, daemonAddr: testDaemonAddr, elevator: elev}, daemon
-}
-
-func TestSetGuardedSettingsPassesOnlyTheChangedSettings(t *testing.T) {
-	s, elev := settingsWithElevation(t, nil)
-
-	root := true
-	outcome, err := s.SetGuardedSettings(context.Background(), GuardedSettings{
-		ProfileName:   "work",
-		Username:      "vma",
-		EnableSSHRoot: &root,
-	})
-	require.NoError(t, err)
-	assert.False(t, outcome.Declined, "the prompt was answered")
-
-	want := []string{
-		"--" + FlagApplyPrivilegedSettings,
-		"--" + FlagDaemonAddr, testDaemonAddr,
-		"--" + FlagProfile, "work",
-		"--" + FlagUser, "vma",
-		"--" + FlagEnableSSHRoot + "=true",
-	}
-	require.Len(t, elev.calls, 1, "one prompt for one change")
-	assert.Equal(t, want, elev.calls[0], "elevated arguments")
-}
-
-// Turning a setting off has to be as explicit as turning it on: a bare flag would
-// read as "on" to the one-shot's parser.
-func TestSetGuardedSettingsSpellsOutFalse(t *testing.T) {
-	s, elev := settingsWithElevation(t, nil)
-
-	off := false
-	_, err := s.SetGuardedSettings(context.Background(), GuardedSettings{
-		ProfileName:      "default",
-		ServerSSHAllowed: &off,
-		DisableSSHAuth:   &off,
-	})
-	require.NoError(t, err)
-
-	args := elev.calls[0]
-	assert.Contains(t, args, "--"+FlagAllowServerSSH+"=false", "the setting being switched off")
-	assert.Contains(t, args, "--"+FlagDisableSSHAuth+"=false", "the setting being switched off")
-	assert.NotContains(t, args, "--"+FlagEnableSSHRoot+"=false", "no flag for a setting nobody touched")
-}
-
-func TestSetGuardedSettingsPassesTheManagementURL(t *testing.T) {
-	s, elev := settingsWithElevation(t, nil)
-
-	_, err := s.SetGuardedSettings(context.Background(), GuardedSettings{
-		ProfileName:   "default",
-		ManagementURL: "https://mgmt.example.com:33073",
-	})
-	require.NoError(t, err)
-
-	assert.Contains(t, elev.calls[0], "--"+FlagManagementURL+"=https://mgmt.example.com:33073",
-		"the management URL to point the profile at")
-}
-
-func TestSetGuardedSettingsWithoutASettingDoesNotElevate(t *testing.T) {
-	s, elev := settingsWithElevation(t, nil)
-
-	_, err := s.SetGuardedSettings(context.Background(), GuardedSettings{ProfileName: "default"})
-
-	require.Error(t, err, "nothing to apply is not something to prompt for")
-	assert.Empty(t, elev.calls, "no prompt at all")
-}
-
-// A declined prompt is the one ending that is not an error: reporting it as one
-// would have every cancelled prompt logged as a failure.
-func TestSetGuardedSettingsReportsADeclinedPromptAsAnOutcome(t *testing.T) {
-	s, _ := settingsWithElevation(t, elevate.ErrDeclined)
-
-	root := true
-	outcome, err := s.SetGuardedSettings(context.Background(), GuardedSettings{
-		ProfileName:   "default",
-		EnableSSHRoot: &root,
-	})
-
-	require.NoError(t, err, "the user was asked and answered; nothing went wrong")
-	assert.True(t, outcome.Declined, "nothing was applied")
-}
-
-func TestSetGuardedSettingsMapsFailures(t *testing.T) {
-	tests := []struct {
-		name     string
-		outcome  error
-		wantCode string
-	}{
-		{
-			// Nothing to raise a prompt with: the user needs the command.
-			name:     "no mechanism falls back to the command",
-			outcome:  elevate.ErrUnavailable,
-			wantCode: CodeElevationUnavailable,
-		},
-		{
-			name:     "a failed run falls back to the command",
-			outcome:  errors.New("elevated netbird exited with 1"),
-			wantCode: CodeElevationFailed,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			s, _ := settingsWithElevation(t, tt.outcome)
-
-			root := true
-			_, err := s.SetGuardedSettings(context.Background(), GuardedSettings{
-				ProfileName:   "default",
-				EnableSSHRoot: &root,
-			})
-
-			var clientErr *ClientError
-			require.ErrorAs(t, err, &clientErr, "the frontend needs a code to act on")
-			assert.Equal(t, tt.wantCode, clientErr.Code, "error code")
-			assert.Contains(t, clientErr.Command, "--"+FlagEnableSSHRoot+"=true",
-				"the setting in the fallback command")
-			assert.Contains(t, clientErr.Command, "netbird up", "the fallback command")
-		})
-	}
-}
-
-// Changing the management URL is only privileged while the host runs the SSH
-// server, which no control can know up front, so the refusal is what triggers the
-// prompt. The original request goes again afterwards, so the fields the one-shot
-// does not understand are applied too.
-func TestSetConfigElevatesAfterARefusalAndRetries(t *testing.T) {
-	elev := &stubElevator{available: true}
-	s, daemon := settingsRefusingOnce(t, elev)
-
-	mtu := int64(1280)
-	outcome, err := s.SetConfig(context.Background(), SetConfigParams{
-		ProfileName:   "default",
-		ManagementURL: "https://mgmt.example.com",
-		MTU:           &mtu,
-	})
-	require.NoError(t, err)
-	assert.False(t, outcome.Declined, "the prompt was answered")
-
-	require.Len(t, elev.calls, 1, "one prompt")
-	assert.Contains(t, elev.calls[0], "--"+FlagManagementURL+"=https://mgmt.example.com",
-		"the guarded part of the request")
-	require.Len(t, daemon.requests, 2, "the refused request and the retry")
-	assert.Equal(t, mtu, daemon.requests[1].GetMtu(),
-		"the retry carries the rest of the request, which the one-shot does not understand")
-}
-
-func TestSetConfigDoesNotRetryWhenTheUserDeclines(t *testing.T) {
-	elev := &stubElevator{outcome: elevate.ErrDeclined, available: true}
-	s, daemon := settingsRefusingOnce(t, elev)
-
-	outcome, err := s.SetConfig(context.Background(), SetConfigParams{
-		ProfileName:   "default",
-		ManagementURL: "https://mgmt.example.com",
-	})
-
-	require.NoError(t, err, "a declined prompt is not an error")
-	assert.True(t, outcome.Declined, "nothing was applied")
-	assert.Len(t, daemon.requests, 1, "only the refused request")
-}
-
-// With no prompt to raise, the refusal is reported as the daemon wrote it, which is
-// the guidance that was there before elevation existed.
-func TestSetConfigReportsTheRefusalWhenItCannotElevate(t *testing.T) {
-	elev := &stubElevator{available: false}
-	s, _ := settingsRefusingOnce(t, elev)
-
-	_, err := s.SetConfig(context.Background(), SetConfigParams{
-		ProfileName:   "default",
-		ManagementURL: "https://mgmt.example.com",
-	})
-
-	var clientErr *ClientError
-	require.ErrorAs(t, err, &clientErr)
-	assert.Equal(t, "privilege_required", clientErr.Code, "error code")
-	assert.Contains(t, clientErr.Command, "netbird up -m https://mgmt.example.com",
-		"the daemon's own command")
-	assert.Empty(t, elev.calls, "no prompt where there is none to raise")
-}
-
-// One authorization must buy only the change the user made. A settings form
-// submits every field it holds, so most of a refused request restates what the
-// daemon already has, and elevating those too would apply a guarded setting the
-// user never touched — a value gone stale since the form loaded above all.
-func TestSetConfigElevatesOnlyTheGuardedSettingsThatChange(t *testing.T) {
-	elev := &stubElevator{available: true}
-	s, _ := settingsRefusingOnce(t, elev)
-
-	on, off := true, false
-	_, err := s.SetConfig(context.Background(), SetConfigParams{
-		ProfileName:      "default",
-		ManagementURL:    storedManagementURL,
-		ServerSSHAllowed: &off,
-		EnableSSHRoot:    &off,
-		DisableSSHAuth:   &on,
-	})
-	require.NoError(t, err)
-
-	require.Len(t, elev.calls, 1, "one prompt")
-	args := elev.calls[0]
-	assert.Contains(t, args, "--"+FlagDisableSSHAuth+"=true", "the setting that changes")
-	assert.NotContains(t, args, "--"+FlagManagementURL+"="+storedManagementURL,
-		"a management URL the daemon already holds")
-	assert.NotContains(t, args, "--"+FlagAllowServerSSH+"=false", "a setting already off")
-	assert.NotContains(t, args, "--"+FlagEnableSSHRoot+"=false", "a setting already off")
-}
-
-// A request that changes no guarded setting has nothing an elevated run could
-// apply, so the refusal must have come from somewhere a prompt cannot reach.
-func TestSetConfigDoesNotElevateWhenNoGuardedSettingChanges(t *testing.T) {
-	elev := &stubElevator{available: true}
-	s, _ := settingsRefusingOnce(t, elev)
-
-	off := false
-	_, err := s.SetConfig(context.Background(), SetConfigParams{
-		ProfileName:      "default",
-		ManagementURL:    storedManagementURL,
-		ServerSSHAllowed: &off,
-	})
-
-	var clientErr *ClientError
-	require.ErrorAs(t, err, &clientErr)
-	assert.Equal(t, "privilege_required", clientErr.Code, "error code")
-	assert.Empty(t, elev.calls, "no prompt for a change nobody made")
-}
-
-// A refusal with nothing in the request the one-shot could apply: the daemon
-// cannot see who is calling, and being root would not help either.
-func TestSetConfigReportsARefusalWithNothingToElevate(t *testing.T) {
-	elev := &stubElevator{available: true}
-	s, _ := settingsRefusingOnce(t, elev)
-
-	_, err := s.SetConfig(context.Background(), SetConfigParams{ProfileName: "default"})
-
-	var clientErr *ClientError
-	require.ErrorAs(t, err, &clientErr)
-	assert.Equal(t, "privilege_required", clientErr.Code, "error code")
-	assert.Empty(t, elev.calls, "no prompt")
-}

client/ui/services/oneshot.go

@@ -1,239 +0,0 @@
-//go:build !android && !ios && !freebsd && !js
-
-package services
-
-import (
-	"context"
-	"errors"
-	"flag"
-	"fmt"
-	"os"
-	"strconv"
-	"time"
-
-	gstatus "google.golang.org/grpc/status"
-
-	"github.com/netbirdio/netbird/client/internal/elevate"
-	"github.com/netbirdio/netbird/client/internal/profilemanager"
-	"github.com/netbirdio/netbird/client/proto"
-	"github.com/netbirdio/netbird/util"
-)
-
-// The other end of SetGuardedSettings: the mode this binary runs itself in,
-// elevated, to apply the settings the daemon restricts to root/administrator.
-//
-// Both ends are here on purpose. What may be changed this way is an allowlist, and
-// an allowlist declared twice is one that will eventually disagree with itself, so
-// the arguments are rendered and parsed from a single table: guardedFields. Adding
-// a setting is one row; nothing generic passes through, and no field outside the
-// table can be reached with an elevated request no matter what lands on the command
-// line.
-
-// oneShotTimeout bounds the whole one-shot: connect, one RPC, exit. Generous
-// because the user has just waited for an authentication dialog, and a failure here
-// costs them the entire round trip.
-const oneShotTimeout = 30 * time.Second
-
-// Exit codes the parent reads where the platform gives it one.
-const (
-	exitOK      = 0
-	exitFailure = 1
-	exitUsage   = 2
-)
-
-// guardedField is one setting the one-shot understands, in the two spellings it
-// needs and with the two halves of its plumbing.
-type guardedField struct {
-	// flag names it on the one-shot's command line.
-	flag  string
-	usage string
-	// read returns the value to send and whether the caller asked for this setting
-	// at all.
-	read func(GuardedSettings) (string, bool)
-	// write parses a value from the command line onto the request. It is the only
-	// thing that validates the value, so it fails on anything it does not
-	// recognise rather than guessing.
-	write func(*proto.SetConfigRequest, string) error
-	// up renders the equivalent `netbird up` flag, for the fallback command shown
-	// when there is no prompt to raise.
-	up func(value string) string
-}
-
-var guardedFields = []guardedField{
-	{
-		flag:  FlagManagementURL,
-		usage: "Management server the profile registers with.",
-		read:  func(p GuardedSettings) (string, bool) { return p.ManagementURL, p.ManagementURL != "" },
-		write: func(req *proto.SetConfigRequest, value string) error {
-			// Parsed with the config layer's own parser, so what the elevated run
-			// accepts cannot drift from what the daemon would store.
-			if _, err := profilemanager.ParseServiceURL("Management URL", value); err != nil {
-				return err
-			}
-			req.ManagementUrl = value
-			return nil
-		},
-		// The daemon names this one as `-m <url>` in its own refusals.
-		up: func(value string) string { return "-m " + value },
-	},
-	boolField(FlagAllowServerSSH, "Run the NetBird SSH server.",
-		func(p GuardedSettings) *bool { return p.ServerSSHAllowed },
-		func(req *proto.SetConfigRequest, v *bool) { req.ServerSSHAllowed = v }),
-	boolField(FlagEnableSSHRoot, "Allow SSH sessions to privileged accounts.",
-		func(p GuardedSettings) *bool { return p.EnableSSHRoot },
-		func(req *proto.SetConfigRequest, v *bool) { req.EnableSSHRoot = v }),
-	boolField(FlagDisableSSHAuth, "Accept SSH sessions without authentication.",
-		func(p GuardedSettings) *bool { return p.DisableSSHAuth },
-		func(req *proto.SetConfigRequest, v *bool) { req.DisableSSHAuth = v }),
-}
-
-// fieldValue is a flag that remembers whether it was given, and requires a value:
-// the renderer always writes one, so a bare flag is a caller that got it wrong.
-type fieldValue struct {
-	set   bool
-	value string
-}
-
-func (v *fieldValue) String() string {
-	if v == nil {
-		return ""
-	}
-	return v.value
-}
-
-func (v *fieldValue) Set(value string) error {
-	v.set, v.value = true, value
-	return nil
-}
-
-// boolField describes a setting that is on or off. The value is always spelled out,
-// so that turning a setting off is as unambiguous as turning it on and a flag with
-// no value is a mistake rather than an "on".
-func boolField(
-	name, usage string,
-	read func(GuardedSettings) *bool,
-	write func(*proto.SetConfigRequest, *bool),
-) guardedField {
-	return guardedField{
-		flag:  name,
-		usage: usage,
-		read: func(p GuardedSettings) (string, bool) {
-			value := read(p)
-			if value == nil {
-				return "", false
-			}
-			return strconv.FormatBool(*value), true
-		},
-		write: func(req *proto.SetConfigRequest, value string) error {
-			parsed, err := strconv.ParseBool(value)
-			if err != nil {
-				return fmt.Errorf("parse %q as a boolean: %w", value, err)
-			}
-			write(req, &parsed)
-			return nil
-		},
-		up: func(value string) string { return "--" + name + "=" + value },
-	}
-}
-
-// IsPrivilegedSettingsRun reports whether this process was started as the one-shot.
-// The flag is a marker rather than a value, so only the bare forms count: reading a
-// value would mean "--flag=false" started it too.
-func IsPrivilegedSettingsRun(args []string) bool {
-	for _, arg := range args {
-		if arg == "--"+FlagApplyPrivilegedSettings || arg == "-"+FlagApplyPrivilegedSettings {
-			return true
-		}
-	}
-	return false
-}
-
-// RunPrivilegedSettings applies the requested settings and returns the process exit
-// code. connect dials the daemon, which is the caller's business because only it
-// knows how this build talks to it.
-//
-// Everything it reports goes to stderr, which is what the parent captures where the
-// platform lets it. On success it says so on standard output, because macOS gives
-// the parent no exit status to read: see elevate.AppliedMarker.
-func RunPrivilegedSettings(args []string, connect func(addr string) (proto.DaemonServiceClient, error)) int {
-	fs := flag.NewFlagSet("netbird-ui --"+FlagApplyPrivilegedSettings, flag.ContinueOnError)
-	fs.Bool(FlagApplyPrivilegedSettings, false, "Apply the settings the daemon restricts to root/administrator and exit.")
-	daemonAddr := fs.String(FlagDaemonAddr, "", "Daemon gRPC address: unix:///path, npipe://name or tcp://host:port")
-	logLevel := fs.String(FlagLogLevel, "info", "Log level: trace|debug|info|warn|error.")
-	profile := fs.String(FlagProfile, "", "Profile to change.")
-	username := fs.String(FlagUser, "", "Owner of the profile.")
-
-	values := make([]fieldValue, len(guardedFields))
-	for i, field := range guardedFields {
-		fs.Var(&values[i], field.flag, field.usage)
-	}
-
-	if err := fs.Parse(args); err != nil {
-		return exitUsage
-	}
-
-	if err := util.InitLog(*logLevel, "console"); err != nil {
-		fmt.Fprintf(os.Stderr, "init log: %v\n", err)
-		return exitFailure
-	}
-
-	req, err := privilegedRequest(*profile, *username, values)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "%v\n", err)
-		return exitUsage
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), oneShotTimeout)
-	defer cancel()
-
-	if err := applyPrivilegedSettings(ctx, *daemonAddr, req, connect); err != nil {
-		fmt.Fprintf(os.Stderr, "apply settings: %v\n", err)
-		return exitFailure
-	}
-
-	fmt.Fprintln(os.Stdout, elevate.AppliedMarker)
-	return exitOK
-}
-
-// privilegedRequest builds the request from the flags that were given, and refuses
-// one that asks for nothing.
-func privilegedRequest(profile, username string, values []fieldValue) (*proto.SetConfigRequest, error) {
-	req := &proto.SetConfigRequest{ProfileName: profile, Username: username}
-
-	given := 0
-	for i, field := range guardedFields {
-		if !values[i].set {
-			continue
-		}
-		if err := field.write(req, values[i].value); err != nil {
-			return nil, fmt.Errorf("--%s: %w", field.flag, err)
-		}
-		given++
-	}
-	if given == 0 {
-		return nil, errors.New("no setting to apply")
-	}
-	return req, nil
-}
-
-func applyPrivilegedSettings(
-	ctx context.Context,
-	daemonAddr string,
-	req *proto.SetConfigRequest,
-	connect func(addr string) (proto.DaemonServiceClient, error),
-) error {
-	client, err := connect(daemonAddr)
-	if err != nil {
-		return err
-	}
-	if _, err := client.SetConfig(ctx, req); err != nil {
-		// Unwrapped: the daemon's message is written for a person, and a refusal
-		// elevation cannot fix has to say so where the parent can read it off
-		// stderr.
-		return errors.New(gstatus.Convert(err).Message())
-	}
-	return nil
-}
-
-// interface guard: the one-shot's flags are flag.Value.
-var _ flag.Value = (*fieldValue)(nil)

client/ui/services/oneshot_test.go

@@ -1,151 +0,0 @@
-//go:build !android && !ios && !freebsd && !js
-
-package services
-
-import (
-	"flag"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/netbirdio/netbird/client/proto"
-)
-
-func TestIsPrivilegedSettingsRun(t *testing.T) {
-	tests := []struct {
-		name string
-		args []string
-		want bool
-	}{
-		{name: "no arguments"},
-		{name: "double dash", args: []string{"--" + FlagApplyPrivilegedSettings}, want: true},
-		{name: "single dash", args: []string{"-" + FlagApplyPrivilegedSettings}, want: true},
-		{
-			name: "among other flags",
-			args: []string{"--daemon-addr", "unix:///tmp/x.sock", "--" + FlagApplyPrivilegedSettings},
-			want: true,
-		},
-		// A marker, not a value: the caller never passes one, and reading a value
-		// would mean "--flag=false" started the one-shot too.
-		{name: "with a value", args: []string{"--" + FlagApplyPrivilegedSettings + "=true"}},
-		{name: "unrelated flags", args: []string{"--log-level", "debug"}},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			assert.Equal(t, tt.want, IsPrivilegedSettingsRun(tt.args), "args %v", tt.args)
-		})
-	}
-}
-
-// What SetGuardedSettings renders has to be what the one-shot reads back, for every
-// setting in the table. This is the property that keeps the two ends of an allowlist
-// from drifting, so it is checked field by field rather than by example.
-func TestGuardedFieldsRoundTrip(t *testing.T) {
-	on, off := true, false
-	tests := []struct {
-		name     string
-		settings GuardedSettings
-		want     func(*testing.T, *proto.SetConfigRequest)
-	}{
-		{
-			name:     "management url",
-			settings: GuardedSettings{ManagementURL: "https://mgmt.example.com:33073"},
-			want: func(t *testing.T, req *proto.SetConfigRequest) {
-				assert.Equal(t, "https://mgmt.example.com:33073", req.GetManagementUrl())
-			},
-		},
-		{
-			name:     "ssh server on",
-			settings: GuardedSettings{ServerSSHAllowed: &on},
-			want: func(t *testing.T, req *proto.SetConfigRequest) {
-				require.NotNil(t, req.ServerSSHAllowed)
-				assert.True(t, *req.ServerSSHAllowed)
-			},
-		},
-		{
-			name:     "ssh root off",
-			settings: GuardedSettings{EnableSSHRoot: &off},
-			want: func(t *testing.T, req *proto.SetConfigRequest) {
-				require.NotNil(t, req.EnableSSHRoot, "an explicit false must survive, not read as absent")
-				assert.False(t, *req.EnableSSHRoot)
-			},
-		},
-		{
-			name:     "ssh auth off",
-			settings: GuardedSettings{DisableSSHAuth: &on},
-			want: func(t *testing.T, req *proto.SetConfigRequest) {
-				require.NotNil(t, req.DisableSSHAuth)
-				assert.True(t, *req.DisableSSHAuth)
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			req := parseRendered(t, tt.settings)
-			tt.want(t, req)
-		})
-	}
-}
-
-// A setting nobody asked about must not arrive at the daemon at all: sending its
-// zero value would change it.
-func TestGuardedFieldsCarryOnlyWhatWasAsked(t *testing.T) {
-	on := true
-	req := parseRendered(t, GuardedSettings{ProfileName: "work", EnableSSHRoot: &on})
-
-	assert.Equal(t, "work", req.GetProfileName(), "profile")
-	require.NotNil(t, req.EnableSSHRoot)
-	assert.Nil(t, req.ServerSSHAllowed, "untouched setting")
-	assert.Nil(t, req.DisableSSHAuth, "untouched setting")
-	assert.Empty(t, req.GetManagementUrl(), "untouched setting")
-}
-
-func TestPrivilegedRequestRejectsAnEmptyChange(t *testing.T) {
-	_, err := privilegedRequest("default", "vma", make([]fieldValue, len(guardedFields)))
-	require.Error(t, err, "nothing to apply is not a request worth sending as root")
-}
-
-// A value the table cannot parse is refused rather than guessed at.
-func TestPrivilegedRequestRejectsAnUnparseableValue(t *testing.T) {
-	values := make([]fieldValue, len(guardedFields))
-	for i, field := range guardedFields {
-		if field.flag != FlagEnableSSHRoot {
-			continue
-		}
-		require.NoError(t, values[i].Set("perhaps"))
-	}
-
-	_, err := privilegedRequest("default", "vma", values)
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), FlagEnableSSHRoot, "which flag was wrong")
-}
-
-// parseRendered puts the settings through both ends: rendered as the arguments the
-// elevated process is given, then parsed by a flag set registered from the same
-// table, which is what the one-shot itself parses them with. Anything hand-rolled
-// here would pin down a parser nothing uses.
-func parseRendered(t *testing.T, p GuardedSettings) *proto.SetConfigRequest {
-	t.Helper()
-
-	rendered := guardedSettings(p)
-	require.NotEmpty(t, rendered, "nothing rendered for %+v", p)
-
-	args := make([]string, 0, len(rendered))
-	for _, setting := range rendered {
-		args = append(args, setting.arg)
-	}
-
-	fs := flag.NewFlagSet(t.Name(), flag.ContinueOnError)
-	values := make([]fieldValue, len(guardedFields))
-	for i, field := range guardedFields {
-		fs.Var(&values[i], field.flag, field.usage)
-	}
-	require.NoError(t, fs.Parse(args), "the one-shot's own flag set must accept %v", args)
-
-	req, err := privilegedRequest(p.ProfileName, p.Username, values)
-	require.NoError(t, err)
-	return req
-}

client/ui/services/settings.go

@@ -44,19 +44,12 @@ type Restrictions struct {
 }
 
 // Privilege tells the frontend whether this process may perform the changes the
-// daemon restricts to root/administrator, whether it can ask the operating
-// system for the privileges instead, and the command for each so a control that
-// can do neither can still show the way.
+// daemon restricts to root/administrator, and carries the command for each so a
+// disabled control can show the way to do it.
 type Privilege struct {
 	Privileged bool `json:"privileged"`
-	// ActorKey identifies the principal the operation requires without wording it,
-	// so the frontend can name it in the user's language: see
-	// ipcauth.PrivilegedActorKey. The words are not sent, because English ones
-	// cannot be dropped into a translated sentence.
-	ActorKey string `json:"actorKey"`
-	// CanElevate reports whether a guarded control can offer to authorize the
-	// change through the platform's own prompt: see SetGuardedSettings.
-	CanElevate bool `json:"canElevate"`
+	// Actor names what the operation requires ("root", "administrator privileges").
+	Actor string `json:"actor"`
 	// Commands equivalent to the settings the daemon guards, ready to copy.
 	AllowSSHServer string `json:"allowSshServer"`
 	EnableSSHRoot  string `json:"enableSshRoot"`
@@ -135,9 +128,6 @@ type Settings struct {
 	// daemonAddr is where the daemon listens, used to tell whether it runs as
 	// this user and would therefore authorize us: see Privilege.
 	daemonAddr string
-	// elevator raises the platform's privilege prompt when a change needs more
-	// rights than this process has.
-	elevator elevator
 }
 
 func NewSettings(conn DaemonConn, translator ErrorTranslator, prefs LanguagePreference, daemonAddr string) *Settings {
@@ -145,7 +135,6 @@ func NewSettings(conn DaemonConn, translator ErrorTranslator, prefs LanguagePref
 		conn:       conn,
 		classifier: errorClassifier{translator: translator, prefs: prefs},
 		daemonAddr: daemonAddr,
-		elevator:   osElevator{},
 	}
 }
 
@@ -191,10 +180,10 @@ func (s *Settings) GetConfig(ctx context.Context, p ConfigParams) (Config, error
 	}, nil
 }
 
-func (s *Settings) SetConfig(ctx context.Context, p SetConfigParams) (SaveOutcome, error) {
+func (s *Settings) SetConfig(ctx context.Context, p SetConfigParams) error {
 	cli, err := s.conn.Client()
 	if err != nil {
-		return SaveOutcome{}, err
+		return err
 	}
 	req := &proto.SetConfigRequest{
 		ProfileName:                   p.ProfileName,
@@ -226,92 +215,19 @@ func (s *Settings) SetConfig(ctx context.Context, p SetConfigParams) (SaveOutcom
 		SshJWTCacheTTL:                p.SSHJWTCacheTTL,
 	}
 	if _, err := cli.SetConfig(ctx, req); err != nil {
-		if _, refused := privilegeErrorInfo(err); refused {
-			return s.setConfigElevated(ctx, p, req, err)
-		}
 		// Classified so the frontend gets the daemon's guidance instead of the
-		// gRPC envelope.
-		return SaveOutcome{}, s.classifier.classify(err)
+		// gRPC envelope, which is what a refused privileged change looks like.
+		return s.classifier.classify(err)
 	}
-	return SaveOutcome{}, nil
-}
-
-// setConfigElevated answers a request the daemon refused for want of privileges by
-// asking the user to authorize it, and sending it again if they do. It is the same
-// offer the SSH settings make up front, for the changes a control cannot know are
-// guarded until it is told: repointing a profile at another management server is
-// only privileged while that host runs the SSH server.
-//
-// Two steps, because the elevated one-shot deliberately understands only the
-// settings the daemon guards: it applies those, and the original request then goes
-// through as this user, its privileged parts now asking for nothing that is not
-// already stored. Nothing was applied by the refused attempt — the daemon decides
-// before it writes — so there is no half-applied state to undo either way.
-func (s *Settings) setConfigElevated(ctx context.Context, p SetConfigParams, req *proto.SetConfigRequest, refusal error) (SaveOutcome, error) {
-	if !s.canElevate() {
-		return SaveOutcome{}, s.classifier.classify(refusal)
-	}
-
-	guarded, err := s.guardedChanges(ctx, p)
-	if err != nil {
-		log.Warnf("cannot tell which guarded settings this request changes: %v", err)
-		return SaveOutcome{}, s.classifier.classify(refusal)
-	}
-	if len(guardedSettings(guarded)) == 0 {
-		// Refused over something no prompt can settle, such as a control channel
-		// that carries no caller identity. Report the daemon's own guidance.
-		return SaveOutcome{}, s.classifier.classify(refusal)
-	}
-
-	outcome, err := s.SetGuardedSettings(ctx, guarded)
-	if err != nil || outcome.Declined {
-		return outcome, err
-	}
-
-	cli, err := s.conn.Client()
-	if err != nil {
-		return SaveOutcome{}, err
-	}
-	if _, err := cli.SetConfig(ctx, req); err != nil {
-		return SaveOutcome{}, s.classifier.classify(err)
-	}
-	return SaveOutcome{}, nil
-}
-
-// guardedChanges is the guarded part of a request, reduced to what it actually
-// changes.
-//
-// A settings form submits every field it holds, so a request restates values the
-// daemon already has. Carrying those into the elevated run would spend one
-// authorization on more than the user asked for, and a value that has gone stale
-// since the form was loaded would spend it on something they never asked about.
-func (s *Settings) guardedChanges(ctx context.Context, p SetConfigParams) (GuardedSettings, error) {
-	stored, err := s.GetConfig(ctx, ConfigParams{ProfileName: p.ProfileName, Username: p.Username})
-	if err != nil {
-		return GuardedSettings{}, fmt.Errorf("read the stored config: %w", err)
-	}
-
-	guarded := GuardedSettings{
-		ProfileName:      p.ProfileName,
-		Username:         p.Username,
-		ServerSSHAllowed: changedFlag(p.ServerSSHAllowed, stored.ServerSSHAllowed),
-		EnableSSHRoot:    changedFlag(p.EnableSSHRoot, stored.EnableSSHRoot),
-		DisableSSHAuth:   changedFlag(p.DisableSSHAuth, stored.DisableSSHAuth),
-	}
-	// An empty URL leaves the setting alone, which is the daemon's rule too.
-	if p.ManagementURL != "" && p.ManagementURL != stored.ManagementURL {
-		guarded.ManagementURL = p.ManagementURL
-	}
-	return guarded, nil
+	return nil
 }
 
 // Privilege reports whether this UI process could carry out the changes the
-// daemon restricts to root/administrator, whether it can instead ask the
-// operating system for the privileges when the user wants one of them, and the
-// command that performs the ones users hit in the SSH settings. It applies the
-// daemon's own rule to what it can see locally, so the frontend can decide up
-// front how to present those controls instead of letting a save fail. No daemon
-// round-trip, so it also works while the daemon is down.
+// daemon restricts to root/administrator, and the command that performs the one
+// users hit in the SSH settings. It applies the daemon's own rule to what it can
+// see locally, so the frontend can present those controls as unavailable up front
+// instead of letting a save fail. No daemon round-trip, so it also works while the
+// daemon is down.
 //
 // Being root or an elevated administrator is one way. The other is running as the
 // daemon's own user while the daemon is unprivileged, which the daemon accepts
@@ -321,40 +237,26 @@ func (s *Settings) guardedChanges(ctx context.Context, p SetConfigParams) (Guard
 func (s *Settings) Privilege() Privilege {
 	id, err := ipcauth.CurrentProcessIdentity()
 	if err != nil {
-		// Fail closed: report unprivileged, which only ever asks for more.
+		// Fail closed: report unprivileged, which only ever disables controls.
 		log.Warnf("cannot read this process's identity, treating it as unprivileged: %v", err)
-		return s.newPrivilege(false)
+		return newPrivilege(false)
 	}
 	if id.IsPrivileged() {
-		return s.newPrivilege(true)
+		return newPrivilege(true)
 	}
-	return s.newPrivilege(daemonaddr.DaemonRunsAsSelf(s.daemonAddr))
+	return newPrivilege(daemonaddr.DaemonRunsAsSelf(s.daemonAddr))
 }
 
-func (s *Settings) newPrivilege(privileged bool) Privilege {
+func newPrivilege(privileged bool) Privilege {
 	return Privilege{
 		Privileged:     privileged,
-		ActorKey:       ipcauth.PrivilegedActorKey(),
-		CanElevate:     s.canElevate(),
+		Actor:          ipcauth.PrivilegedActor(),
 		AllowSSHServer: ipcauth.UpCommand("--allow-server-ssh"),
 		EnableSSHRoot:  ipcauth.UpCommand("--enable-ssh-root"),
 		DisableSSHAuth: ipcauth.UpCommand("--disable-ssh-auth"),
 	}
 }
 
-// canElevate reports whether offering the platform's elevation prompt would get
-// the user anywhere. It needs a mechanism to raise the prompt with and a control
-// channel that tells the daemon who is calling: on loopback TCP the daemon
-// refuses these changes to everybody, root included, so a prompt there would
-// only waste the user's password.
-func (s *Settings) canElevate() bool {
-	if !daemonaddr.CarriesIdentity(s.daemonAddr) {
-		log.Debugf("not offering elevation: the daemon address %s carries no caller identity", s.daemonAddr)
-		return false
-	}
-	return s.elevator.Available()
-}
-
 func (s *Settings) GetRestrictions(ctx context.Context) (Restrictions, error) {
 	cli, err := s.conn.Client()
 	if err != nil {
@@ -387,15 +289,6 @@ func (s *Settings) GetRestrictions(ctx context.Context) (Restrictions, error) {
 	return r, nil
 }
 
-// changedFlag returns requested only when it differs from what is stored, so a
-// setting the request merely restates is left out of the elevated run.
-func changedFlag(requested *bool, stored bool) *bool {
-	if requested == nil || *requested == stored {
-		return nil
-	}
-	return requested
-}
-
 func applyMDMRestrictions(mdm *MDMFields, cfgResp *proto.GetConfigResponse) {
 	managed := cfgResp.GetMDMManagedFields()
 	if len(managed) == 0 {

client/ui/tray_click_linux.go

@@ -4,26 +4,17 @@ package main
 
 // bindTrayClick wires the tray icon's left-click handler on Linux.
 //
-// Expected behaviour per tray host:
-//
-//	Host                           Left click              Right click
-//	KDE Plasma, Waybar             main window (Activate)  menu (host-rendered)
-//	GNOME Shell + AppIndicator     menu only               menu only
-//	Minimal WMs via XEmbed host    main window (Activate)  XEmbed GTK popup
-//
-// OnClick fires only on org.kde.StatusNotifierItem.Activate — a real left
-// click. KDE/Waybar send it over D-Bus; the in-process XEmbed host
-// (xembed_host_linux.go) maps a Button1 press to the same Activate call.
-//
-// GNOME Shell + AppIndicator never sends Activate: it renders the dbusmenu
-// on ANY click and only reports the menu opening via dbusmenu
-// Event("opened"). Upstream Wails treated that event as a click, so on GNOME
-// both buttons raised the main window on top of the menu, and on KDE/Waybar
-// a right click raised it over the freshly opened menu. The netbirdio/wails
-// fork (go.mod replace) drops that heuristic: a menu open never fires
-// OnClick. On GNOME the main window is reached via the "Open NetBird" menu
-// entry; left-click-opens-window is not achievable there anyway, since the
-// host always opens the menu itself.
+// Both Linux click paths converge on Wails' linuxSystemTray.Activate, which
+// fires the registered clickHandler:
+//   - Real SNI hosts (KDE Plasma, Waybar, GNOME Shell + AppIndicator) invoke
+//     org.kde.StatusNotifierItem.Activate over D-Bus on left-click.
+//   - The in-process StatusNotifierWatcher + XEmbed host used on minimal WMs
+//     (Fluxbox, i3, dwm, OpenBox) maps a Button1 press to that same Activate
+//     call itself (xembed_host_linux.go), so it routes through the same hook.
+// Registering OnClick here therefore covers both paths with one handler — no
+// changes to the watcher or XEmbed C code are needed. Left-click now opens the
+// main window; right-click still opens the menu via Wails' default
+// SecondaryActivate→OpenMenu handler (and the XEmbed GTK popup on minimal WMs).
 //
 // We do NOT register OnDoubleClick: Wails' Linux SNI backend never fires it
 // (unlike Windows). And we deliberately skip AttachWindow — it plus Wails3's

client/ui/tray_session.go

@@ -27,10 +27,11 @@ const (
 	finalWarningCountdownSeconds = 120
 )
 
-// handleSessionExpired notifies and brings the window forward so the user can reconnect.
+// handleSessionExpired notifies and brings the window forward so the frontend's /login route drives renewal.
 func (t *Tray) handleSessionExpired() {
 	t.notify(t.loc.T("notify.sessionExpired.title"), t.loc.T("notify.sessionExpired.body"), notifyIDSessionExpired)
 	if t.window != nil {
+		t.window.SetURL("/#/login")
 		t.window.Show()
 		t.window.Focus()
 	}
@@ -307,7 +308,11 @@ func (t *Tray) openSessionExtendFlow() {
 	}
 	seconds := int(time.Until(deadline).Seconds())
 	if seconds <= 0 {
-		t.app.Event.Emit(services.EventTriggerLogin)
+		if t.window != nil {
+			t.window.SetURL("/#/login")
+			t.window.Show()
+			t.window.Focus()
+		}
 		return
 	}
 	if t.svc.WindowManager == nil {

go.mod

@@ -339,5 +339,3 @@ replace github.com/dexidp/dex => github.com/netbirdio/dex v0.244.1-0.20260716205
 replace github.com/dexidp/dex/api/v2 => github.com/netbirdio/dex/api/v2 v2.0.0-20260512110716-8d70ad8647c1
 
 replace github.com/mailru/easyjson => github.com/netbirdio/easyjson v0.9.0
-
-replace github.com/wailsapp/wails/v3 => github.com/netbirdio/wails/v3 v3.0.0-beta.3.0.20260803205919-ad21e92381f4

go.sum

@@ -490,8 +490,6 @@ github.com/netbirdio/service v0.0.0-20240911161631-f62744f42502 h1:3tHlFmhTdX9ax
 github.com/netbirdio/service v0.0.0-20240911161631-f62744f42502/go.mod h1:CIMRFEJVL+0DS1a3Nx06NaMn4Dz63Ng6O7dl0qH0zVM=
 github.com/netbirdio/signal-dispatcher/dispatcher v0.0.0-20250805121659-6b4ac470ca45 h1:ujgviVYmx243Ksy7NdSwrdGPSRNE3pb8kEDSpH0QuAQ=
 github.com/netbirdio/signal-dispatcher/dispatcher v0.0.0-20250805121659-6b4ac470ca45/go.mod h1:5/sjFmLb8O96B5737VCqhHyGRzNFIaN/Bu7ZodXc3qQ=
-github.com/netbirdio/wails/v3 v3.0.0-beta.3.0.20260803205919-ad21e92381f4 h1:UKztc3QjWvzU5DZk+uYaOWN0x62NSe/pkxuPvzqZIy4=
-github.com/netbirdio/wails/v3 v3.0.0-beta.3.0.20260803205919-ad21e92381f4/go.mod h1:BzATbK71VFikMMMCo434wAi0QcaI03P+xeaWgDvQvjw=
 github.com/netbirdio/wireguard-go v0.0.0-20260628102922-2834bebf6c1a h1:3CWK+yTvRKOcC0Q8VCTGy4l60TEb27CQVS7LkMxwjmw=
 github.com/netbirdio/wireguard-go v0.0.0-20260628102922-2834bebf6c1a/go.mod h1:rpwXGsirqLqN2L0JDJQlwOboGHmptD5ZD6T2VmcqhTw=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
@@ -662,6 +660,8 @@ github.com/vmihailenco/msgpack/v5 v5.4.1 h1:cQriyiUvjTwOHg8QZaPihLWeRAAVoCpE00IU
 github.com/vmihailenco/msgpack/v5 v5.4.1/go.mod h1:GaZTsDaehaPpQVyxrf5mtQlH+pc21PIudVV/E3rRQok=
 github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=
 github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
+github.com/wailsapp/wails/v3 v3.0.0-beta.3 h1:BrcZunEBVucncRx+xgkk9TzlXU4qc0ygJuEhKAAGaeA=
+github.com/wailsapp/wails/v3 v3.0.0-beta.3/go.mod h1:BzATbK71VFikMMMCo434wAi0QcaI03P+xeaWgDvQvjw=
 github.com/wlynxg/anet v0.0.5 h1:J3VJGi1gvo0JwZ/P1/Yc/8p63SoW98B5dHkYDmpgvvU=
 github.com/wlynxg/anet v0.0.5/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA=
 github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=

management/internals/modules/agentnetwork/manager.go

@@ -82,6 +82,11 @@ type Manager interface {
 	RecordAccountBudgetUsage(ctx context.Context, accountID, userID string, groupIDs []string, tokensIn, tokensOut int64, costUSD float64) error
 	RecordUsage(ctx context.Context, in RecordUsageInput) error
 	SelectPolicyForRequest(ctx context.Context, in PolicySelectionInput) (*PolicySelectionResult, error)
+
+	// GetSetupForPeer returns the Agent Network connection info the peer's
+	// groups authorize (endpoint, providers, effective models). Caller-scoped
+	// by design — no user permission gate; see the implementation.
+	GetSetupForPeer(ctx context.Context, accountID, peerID string) (*types.EffectiveSetup, error)
 }
 
 // PolicySelectionInput is the per-request selection envelope. The

management/internals/modules/agentnetwork/setup.go

@@ -0,0 +1,240 @@
+package agentnetwork
+
+import (
+	"context"
+	"fmt"
+	"sort"
+
+	"github.com/netbirdio/netbird/management/internals/modules/agentnetwork/catalog"
+	"github.com/netbirdio/netbird/management/internals/modules/agentnetwork/types"
+	"github.com/netbirdio/netbird/management/server/store"
+)
+
+// GetSetupForPeer returns the Agent Network setup the calling peer's
+// groups authorize. It deliberately performs no user-permission check:
+// peer RPCs carry no user identity — WireGuard key possession is the
+// credential (same trust model as SelectPolicyForRequest) — and the
+// result is caller-scoped, which is strictly tighter than any role gate.
+// Setup-key/machine peers (no user attached) are fully supported since
+// the computation runs on peer groups, which is what the proxy enforces.
+func (m *managerImpl) GetSetupForPeer(ctx context.Context, accountID, peerID string) (*types.EffectiveSetup, error) {
+	groupIDs, err := m.store.GetPeerGroupIDs(ctx, store.LockingStrengthNone, accountID, peerID)
+	if err != nil {
+		return nil, fmt.Errorf("get peer groups: %w", err)
+	}
+	return m.effectiveSetupForGroups(ctx, accountID, groupIDs)
+}
+
+// effectiveSetupForGroups computes the effective Agent Network setup for
+// a set of caller groups: the account endpoint plus, per authorized
+// provider, the effective model set. It mirrors what the proxy enforces
+// at request time — the policy filter matches filterApplicablePolicies,
+// the model logic matches policyPermitsModel, and orphan providers
+// (enabled but referenced by no applicable policy) are omitted just like
+// the router synthesizer omits them — so the answer never advertises
+// anything the proxy would refuse.
+//
+// Every "nothing available" shape returns Configured=false rather than
+// an error, and "account not set up" is indistinguishable from "caller
+// has no access" by design: the response must not leak what exists for
+// others.
+func (m *managerImpl) effectiveSetupForGroups(ctx context.Context, accountID string, groupIDs []string) (*types.EffectiveSetup, error) {
+	notConfigured := &types.EffectiveSetup{Providers: []types.EffectiveProvider{}}
+
+	settings, err := m.store.GetAgentNetworkSettings(ctx, store.LockingStrengthNone, accountID)
+	switch {
+	case err == nil:
+	case isNotFound(err):
+		return notConfigured, nil
+	default:
+		return nil, fmt.Errorf("get agent network settings: %w", err)
+	}
+	if settings.Endpoint() == "" {
+		return notConfigured, nil
+	}
+
+	policies, err := m.store.GetAccountAgentNetworkPolicies(ctx, store.LockingStrengthNone, accountID)
+	if err != nil {
+		return nil, fmt.Errorf("list account policies: %w", err)
+	}
+	applicable := filterPoliciesByGroups(policies, groupIDs)
+	if len(applicable) == 0 {
+		return notConfigured, nil
+	}
+
+	providers, err := m.store.GetAccountAgentNetworkProviders(ctx, store.LockingStrengthNone, accountID)
+	if err != nil {
+		return nil, fmt.Errorf("list account providers: %w", err)
+	}
+
+	var guardrailsByID map[string]*types.Guardrail
+	if anyPolicyHasGuardrails(applicable) {
+		guardrailsByID, err = m.loadGuardrailsByID(ctx, accountID)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	authorized := make([]*types.Provider, 0, len(providers))
+	for _, p := range providers {
+		if p == nil || !p.Enabled {
+			continue
+		}
+		if len(policiesForProvider(applicable, p.ID)) == 0 {
+			continue
+		}
+		authorized = append(authorized, p)
+	}
+	if len(authorized) == 0 {
+		return notConfigured, nil
+	}
+	// created_at order, ID tiebreak — same deterministic order the router
+	// synthesizer presents.
+	sort.SliceStable(authorized, func(i, j int) bool {
+		if !authorized[i].CreatedAt.Equal(authorized[j].CreatedAt) {
+			return authorized[i].CreatedAt.Before(authorized[j].CreatedAt)
+		}
+		return authorized[i].ID < authorized[j].ID
+	})
+
+	out := &types.EffectiveSetup{
+		Configured: true,
+		Endpoint:   "https://" + settings.Endpoint(),
+		Providers:  make([]types.EffectiveProvider, 0, len(authorized)),
+	}
+	for _, p := range authorized {
+		allAllowed, models := effectiveModelsForProvider(p, policiesForProvider(applicable, p.ID), guardrailsByID)
+		flavor := ""
+		if entry, ok := catalog.Lookup(p.ProviderID); ok {
+			flavor = entry.ParserID
+		}
+		out.Providers = append(out.Providers, types.EffectiveProvider{
+			Name:             p.Name,
+			CatalogID:        p.ProviderID,
+			APIFlavor:        flavor,
+			AllModelsAllowed: allAllowed,
+			Models:           models,
+		})
+	}
+	return out, nil
+}
+
+// filterPoliciesByGroups returns the enabled policies whose SourceGroups
+// intersect the caller's groups. Same group matching as
+// filterApplicablePolicies, without the per-provider filter — the setup
+// answer spans every provider the caller can reach.
+func filterPoliciesByGroups(policies []*types.Policy, groupIDs []string) []*types.Policy {
+	groupSet := make(map[string]struct{}, len(groupIDs))
+	for _, g := range groupIDs {
+		if g != "" {
+			groupSet[g] = struct{}{}
+		}
+	}
+	out := make([]*types.Policy, 0, len(policies))
+	for _, p := range policies {
+		if p == nil || !p.Enabled {
+			continue
+		}
+		if !anyGroupMatches(p.SourceGroups, groupSet) {
+			continue
+		}
+		out = append(out, p)
+	}
+	return out
+}
+
+// policiesForProvider returns the subset of policies targeting the
+// provider, order preserved.
+func policiesForProvider(policies []*types.Policy, providerID string) []*types.Policy {
+	out := make([]*types.Policy, 0, len(policies))
+	for _, p := range policies {
+		if sliceContains(p.DestinationProviderIDs, providerID) {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
+// effectiveModelsForProvider derives the caller's effective model set for
+// one provider from the applicable policies that target it, mirroring
+// policyPermitsModel: a policy with no allowlist-enabled guardrail is
+// unrestricted, and one unrestricted policy makes the whole provider
+// unrestricted (the proxy would admit any model through it). Otherwise
+// the union of the policies' allowlists applies, intersected with the
+// provider's declared models when the operator declared any — the router
+// only claims declared models, so an allowlisted-but-undeclared model is
+// unreachable and must not be advertised. With no declared models the
+// router claims every model, so the allowlist union stands alone.
+func effectiveModelsForProvider(provider *types.Provider, policies []*types.Policy, guardrailsByID map[string]*types.Guardrail) (bool, []string) {
+	restricted := true
+	union := make([]string, 0)
+	seen := make(map[string]struct{})
+	for _, p := range policies {
+		policyRestricted := false
+		for _, gID := range p.GuardrailIDs {
+			g, ok := guardrailsByID[gID]
+			if !ok || g == nil || !g.Checks.ModelAllowlist.Enabled {
+				continue
+			}
+			policyRestricted = true
+			for _, model := range g.Checks.ModelAllowlist.Models {
+				key := normaliseModelID(model)
+				if key == "" {
+					continue
+				}
+				if _, dup := seen[key]; dup {
+					continue
+				}
+				seen[key] = struct{}{}
+				union = append(union, key)
+			}
+		}
+		if !policyRestricted {
+			restricted = false
+		}
+	}
+
+	declared := declaredModelIDs(provider)
+	if !restricted {
+		return true, declared
+	}
+	if len(provider.Models) == 0 {
+		// No operator declaration: the router claims every model, so the
+		// allowlist union is the effective set as-is.
+		return false, union
+	}
+	out := make([]string, 0, len(declared))
+	for _, id := range declared {
+		if _, ok := seen[normaliseModelID(id)]; ok {
+			out = append(out, id)
+		}
+	}
+	return false, out
+}
+
+// declaredModelIDs returns the models a provider exposes: the operator's
+// curated list when present, otherwise the catalog entry's models (an
+// empty operator list means "all catalog models"). Gateway/custom catalog
+// entries declare no models, so the result may be empty.
+func declaredModelIDs(provider *types.Provider) []string {
+	if ids := providerModelIDs(provider); len(ids) > 0 {
+		return ids
+	}
+	entry, ok := catalog.Lookup(provider.ProviderID)
+	if !ok {
+		return []string{}
+	}
+	out := make([]string, 0, len(entry.Models))
+	for _, m := range entry.Models {
+		if m.ID != "" {
+			out = append(out, m.ID)
+		}
+	}
+	return out
+}
+
+// GetSetupForPeer on the mock manager reports "not configured" so tests
+// that don't care about setup still compile.
+func (*mockManager) GetSetupForPeer(_ context.Context, _, _ string) (*types.EffectiveSetup, error) {
+	return &types.EffectiveSetup{Providers: []types.EffectiveProvider{}}, nil
+}

management/internals/modules/agentnetwork/setup_realstore_test.go

@@ -0,0 +1,271 @@
+package agentnetwork
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/netbirdio/netbird/management/internals/modules/agentnetwork/types"
+	"github.com/netbirdio/netbird/management/server/store"
+)
+
+// These tests drive the effective-setup computation through the real
+// sqlite store, mirroring the policyselect realstore suite: assert on
+// observable answers (configured / providers / models), not on which
+// store methods get called. The computation must agree with what the
+// proxy enforces — policy filtering matches filterApplicablePolicies,
+// model logic matches policyPermitsModel, and orphan providers are
+// omitted like the router synthesizer omits them.
+
+func newSetupTestMgr(t *testing.T) (*managerImpl, store.Store) {
+	t.Helper()
+	ctx := context.Background()
+	s, cleanup, err := store.NewTestStoreFromSQL(ctx, "", t.TempDir())
+	require.NoError(t, err, "real sqlite test store must come up")
+	t.Cleanup(cleanup)
+	return &managerImpl{store: s}, s
+}
+
+// newSetupTestGuardrail returns an allowlist-enabled guardrail.
+func newSetupTestGuardrail(id string, models ...string) *types.Guardrail {
+	return &types.Guardrail{
+		ID:        id,
+		AccountID: testAccountID,
+		Name:      "allowlist " + id,
+		Checks: types.GuardrailChecks{
+			ModelAllowlist: types.GuardrailModelAllowlist{Enabled: true, Models: models},
+		},
+	}
+}
+
+func TestEffectiveSetup_RealStore_NoSettingsRow(t *testing.T) {
+	mgr, _ := newSetupTestMgr(t)
+
+	setup, err := mgr.effectiveSetupForGroups(context.Background(), testAccountID, []string{"grp-eng"})
+	require.NoError(t, err)
+	assert.False(t, setup.Configured, "account without settings must read as not configured")
+	assert.Empty(t, setup.Endpoint)
+	assert.Empty(t, setup.Providers)
+}
+
+func TestEffectiveSetup_RealStore_NoApplicablePolicy(t *testing.T) {
+	mgr, s := newSetupTestMgr(t)
+	ctx := context.Background()
+
+	require.NoError(t, s.SaveAgentNetworkSettings(ctx, newSynthTestSettings()))
+	provider := newSynthTestProvider()
+	require.NoError(t, s.SaveAgentNetworkProvider(ctx, provider))
+	require.NoError(t, s.SaveAgentNetworkPolicy(ctx, newSynthTestPolicy(provider.ID, "grp-eng", "")))
+
+	setup, err := mgr.effectiveSetupForGroups(ctx, testAccountID, []string{"grp-other"})
+	require.NoError(t, err)
+	assert.False(t, setup.Configured, "caller outside every policy's source groups must read as not configured")
+	assert.Empty(t, setup.Endpoint, "no-access answer must not leak the endpoint")
+	assert.Empty(t, setup.Providers)
+}
+
+func TestEffectiveSetup_RealStore_UnrestrictedPolicyListsDeclaredModels(t *testing.T) {
+	mgr, s := newSetupTestMgr(t)
+	ctx := context.Background()
+
+	require.NoError(t, s.SaveAgentNetworkSettings(ctx, newSynthTestSettings()))
+	provider := newSynthTestProvider()
+	require.NoError(t, s.SaveAgentNetworkProvider(ctx, provider))
+	require.NoError(t, s.SaveAgentNetworkPolicy(ctx, newSynthTestPolicy(provider.ID, "grp-eng", "")))
+
+	setup, err := mgr.effectiveSetupForGroups(ctx, testAccountID, []string{"grp-eng"})
+	require.NoError(t, err)
+	assert.True(t, setup.Configured)
+	assert.Equal(t, "https://"+testEndpoint, setup.Endpoint)
+	require.Len(t, setup.Providers, 1)
+	p := setup.Providers[0]
+	assert.Equal(t, "OpenAI", p.Name)
+	assert.Equal(t, "openai_api", p.CatalogID)
+	assert.Equal(t, "openai", p.APIFlavor)
+	assert.True(t, p.AllModelsAllowed, "policy without allowlist guardrail is unrestricted")
+	assert.Equal(t, []string{"gpt-5.4"}, p.Models, "declared models listed as a courtesy")
+}
+
+func TestEffectiveSetup_RealStore_AllowlistIntersectsDeclaredModels(t *testing.T) {
+	mgr, s := newSetupTestMgr(t)
+	ctx := context.Background()
+
+	require.NoError(t, s.SaveAgentNetworkSettings(ctx, newSynthTestSettings()))
+	provider := newSynthTestProvider()
+	provider.Models = []types.ProviderModel{{ID: "gpt-5.4"}, {ID: "gpt-4o"}}
+	require.NoError(t, s.SaveAgentNetworkProvider(ctx, provider))
+	// Allowlist admits gpt-5.4 (declared, odd casing/spacing) and gpt-4.1
+	// (NOT declared — the router would never route it, so it must not be
+	// advertised).
+	require.NoError(t, s.SaveAgentNetworkGuardrail(ctx, newSetupTestGuardrail("guard-1", " GPT-5.4 ", "gpt-4.1")))
+	require.NoError(t, s.SaveAgentNetworkPolicy(ctx, newSynthTestPolicy(provider.ID, "grp-eng", "guard-1")))
+
+	setup, err := mgr.effectiveSetupForGroups(ctx, testAccountID, []string{"grp-eng"})
+	require.NoError(t, err)
+	require.Len(t, setup.Providers, 1)
+	p := setup.Providers[0]
+	assert.False(t, p.AllModelsAllowed)
+	assert.Equal(t, []string{"gpt-5.4"}, p.Models, "allowlist ∩ declared, in declared order and casing")
+}
+
+func TestEffectiveSetup_RealStore_UnrestrictedPolicyWinsOverRestricted(t *testing.T) {
+	mgr, s := newSetupTestMgr(t)
+	ctx := context.Background()
+
+	require.NoError(t, s.SaveAgentNetworkSettings(ctx, newSynthTestSettings()))
+	provider := newSynthTestProvider()
+	require.NoError(t, s.SaveAgentNetworkProvider(ctx, provider))
+	require.NoError(t, s.SaveAgentNetworkGuardrail(ctx, newSetupTestGuardrail("guard-1", "gpt-5.4")))
+	restricted := newSynthTestPolicy(provider.ID, "grp-eng", "guard-1")
+	require.NoError(t, s.SaveAgentNetworkPolicy(ctx, restricted))
+	open := newSynthTestPolicy(provider.ID, "grp-eng", "")
+	open.ID = "pol-2"
+	require.NoError(t, s.SaveAgentNetworkPolicy(ctx, open))
+
+	setup, err := mgr.effectiveSetupForGroups(ctx, testAccountID, []string{"grp-eng"})
+	require.NoError(t, err)
+	require.Len(t, setup.Providers, 1)
+	assert.True(t, setup.Providers[0].AllModelsAllowed,
+		"one applicable policy without an allowlist makes the provider unrestricted — the proxy would admit any model through it")
+}
+
+func TestEffectiveSetup_RealStore_AllowlistUnionAcrossPolicies(t *testing.T) {
+	mgr, s := newSetupTestMgr(t)
+	ctx := context.Background()
+
+	require.NoError(t, s.SaveAgentNetworkSettings(ctx, newSynthTestSettings()))
+	provider := newSynthTestProvider()
+	provider.Models = []types.ProviderModel{{ID: "gpt-5.4"}, {ID: "gpt-4o"}, {ID: "o4-mini"}}
+	require.NoError(t, s.SaveAgentNetworkProvider(ctx, provider))
+	require.NoError(t, s.SaveAgentNetworkGuardrail(ctx, newSetupTestGuardrail("guard-1", "gpt-5.4")))
+	require.NoError(t, s.SaveAgentNetworkGuardrail(ctx, newSetupTestGuardrail("guard-2", "gpt-4o")))
+	p1 := newSynthTestPolicy(provider.ID, "grp-eng", "guard-1")
+	require.NoError(t, s.SaveAgentNetworkPolicy(ctx, p1))
+	p2 := newSynthTestPolicy(provider.ID, "grp-eng", "guard-2")
+	p2.ID = "pol-2"
+	require.NoError(t, s.SaveAgentNetworkPolicy(ctx, p2))
+
+	setup, err := mgr.effectiveSetupForGroups(ctx, testAccountID, []string{"grp-eng"})
+	require.NoError(t, err)
+	require.Len(t, setup.Providers, 1)
+	p := setup.Providers[0]
+	assert.False(t, p.AllModelsAllowed)
+	assert.ElementsMatch(t, []string{"gpt-5.4", "gpt-4o"}, p.Models, "union of allowlists across applicable policies")
+}
+
+func TestEffectiveSetup_RealStore_OrphanAndDisabledProvidersOmitted(t *testing.T) {
+	mgr, s := newSetupTestMgr(t)
+	ctx := context.Background()
+
+	require.NoError(t, s.SaveAgentNetworkSettings(ctx, newSynthTestSettings()))
+	// Orphan: enabled but referenced by no policy.
+	orphan := newSynthTestProvider()
+	orphan.ID = "prov-orphan"
+	require.NoError(t, s.SaveAgentNetworkProvider(ctx, orphan))
+	// Disabled but referenced by an applicable policy.
+	disabled := newSynthTestProvider()
+	disabled.ID = "prov-disabled"
+	disabled.Enabled = false
+	require.NoError(t, s.SaveAgentNetworkProvider(ctx, disabled))
+	require.NoError(t, s.SaveAgentNetworkPolicy(ctx, newSynthTestPolicy(disabled.ID, "grp-eng", "")))
+
+	setup, err := mgr.effectiveSetupForGroups(ctx, testAccountID, []string{"grp-eng"})
+	require.NoError(t, err)
+	assert.False(t, setup.Configured, "neither an orphan nor a disabled provider is reachable, so nothing is configured for the caller")
+	assert.Empty(t, setup.Providers)
+}
+
+func TestEffectiveSetup_RealStore_DisabledPolicyIgnored(t *testing.T) {
+	mgr, s := newSetupTestMgr(t)
+	ctx := context.Background()
+
+	require.NoError(t, s.SaveAgentNetworkSettings(ctx, newSynthTestSettings()))
+	provider := newSynthTestProvider()
+	require.NoError(t, s.SaveAgentNetworkProvider(ctx, provider))
+	policy := newSynthTestPolicy(provider.ID, "grp-eng", "")
+	policy.Enabled = false
+	require.NoError(t, s.SaveAgentNetworkPolicy(ctx, policy))
+
+	setup, err := mgr.effectiveSetupForGroups(ctx, testAccountID, []string{"grp-eng"})
+	require.NoError(t, err)
+	assert.False(t, setup.Configured)
+}
+
+func TestEffectiveSetup_RealStore_UndeclaredModelsUseAllowlistAsIs(t *testing.T) {
+	mgr, s := newSetupTestMgr(t)
+	ctx := context.Background()
+
+	require.NoError(t, s.SaveAgentNetworkSettings(ctx, newSynthTestSettings()))
+	// Gateway-style provider: no declared models — the router claims every
+	// model, so the allowlist union is the effective set on its own.
+	provider := newSynthTestProvider()
+	provider.ProviderID = "litellm_proxy"
+	provider.Name = "LiteLLM"
+	provider.Models = nil
+	require.NoError(t, s.SaveAgentNetworkProvider(ctx, provider))
+	require.NoError(t, s.SaveAgentNetworkGuardrail(ctx, newSetupTestGuardrail("guard-1", "claude-sonnet-4-5")))
+	require.NoError(t, s.SaveAgentNetworkPolicy(ctx, newSynthTestPolicy(provider.ID, "grp-eng", "guard-1")))
+
+	setup, err := mgr.effectiveSetupForGroups(ctx, testAccountID, []string{"grp-eng"})
+	require.NoError(t, err)
+	require.Len(t, setup.Providers, 1)
+	p := setup.Providers[0]
+	assert.False(t, p.AllModelsAllowed)
+	assert.Equal(t, []string{"claude-sonnet-4-5"}, p.Models)
+}
+
+func TestEffectiveSetup_RealStore_ProvidersInCreatedAtOrder(t *testing.T) {
+	mgr, s := newSetupTestMgr(t)
+	ctx := context.Background()
+
+	require.NoError(t, s.SaveAgentNetworkSettings(ctx, newSynthTestSettings()))
+	newer := newSynthTestProvider()
+	newer.ID = "prov-newer"
+	newer.Name = "Newer"
+	newer.CreatedAt = time.Date(2026, 2, 1, 0, 0, 0, 0, time.UTC)
+	require.NoError(t, s.SaveAgentNetworkProvider(ctx, newer))
+	older := newSynthTestProvider()
+	older.ID = "prov-older"
+	older.Name = "Older"
+	older.CreatedAt = time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
+	require.NoError(t, s.SaveAgentNetworkProvider(ctx, older))
+
+	policy := newSynthTestPolicy(newer.ID, "grp-eng", "")
+	policy.DestinationProviderIDs = []string{newer.ID, older.ID}
+	require.NoError(t, s.SaveAgentNetworkPolicy(ctx, policy))
+
+	setup, err := mgr.effectiveSetupForGroups(ctx, testAccountID, []string{"grp-eng"})
+	require.NoError(t, err)
+	require.Len(t, setup.Providers, 2)
+	assert.Equal(t, "Older", setup.Providers[0].Name)
+	assert.Equal(t, "Newer", setup.Providers[1].Name)
+}
+
+// TestGetSetupForPeer_RealStore pins the peer entry point: the peer's
+// group memberships (not any user identity) scope the answer, which is
+// exactly what the proxy enforces via AllowedGroupIDs — including for
+// setup-key/machine peers that have no user attached.
+func TestGetSetupForPeer_RealStore(t *testing.T) {
+	mgr, s := newSetupTestMgr(t)
+	ctx := context.Background()
+
+	require.NoError(t, s.SaveAgentNetworkSettings(ctx, newSynthTestSettings()))
+	provider := newSynthTestProvider()
+	require.NoError(t, s.SaveAgentNetworkProvider(ctx, provider))
+	require.NoError(t, s.SaveAgentNetworkPolicy(ctx, newSynthTestPolicy(provider.ID, "grp-eng", "")))
+
+	require.NoError(t, s.AddPeerToGroup(ctx, testAccountID, "peer-in", "grp-eng"))
+	require.NoError(t, s.AddPeerToGroup(ctx, testAccountID, "peer-out", "grp-other"))
+
+	setupIn, err := mgr.GetSetupForPeer(ctx, testAccountID, "peer-in")
+	require.NoError(t, err)
+	assert.True(t, setupIn.Configured)
+	require.Len(t, setupIn.Providers, 1)
+
+	setupOut, err := mgr.GetSetupForPeer(ctx, testAccountID, "peer-out")
+	require.NoError(t, err)
+	assert.False(t, setupOut.Configured, "peer outside the policy's source groups gets the not-configured answer")
+}

management/internals/modules/agentnetwork/types/setup.go

@@ -0,0 +1,40 @@
+package types
+
+// EffectiveSetup is the caller-scoped answer to "what may this caller
+// use on the Agent Network?" — the account's proxy endpoint plus the
+// providers and models the caller's groups authorize. It intentionally
+// carries display metadata only: no keys, no upstream URLs, no policy or
+// guardrail structure, and no hint of providers the caller cannot reach.
+type EffectiveSetup struct {
+	// Configured is false when the account has no Agent Network set up or
+	// when nothing is authorized for the caller's groups — the two cases
+	// are deliberately indistinguishable so the response leaks nothing
+	// about what exists for others.
+	Configured bool
+	// Endpoint is the account's proxy base URL
+	// ("https://<subdomain>.<cluster>"), reachable over the NetBird tunnel
+	// only. Empty when Configured is false.
+	Endpoint string
+	// Providers lists the providers at least one applicable policy
+	// authorizes for the caller, in the account's created_at order.
+	Providers []EffectiveProvider
+}
+
+// EffectiveProvider is one authorized provider in an EffectiveSetup.
+type EffectiveProvider struct {
+	// Name is the operator-assigned label, e.g. "Bedrock prod".
+	Name string
+	// CatalogID names the catalog entry, e.g. "anthropic_api".
+	CatalogID string
+	// APIFlavor is the request-body shape the provider speaks — the
+	// catalog entry's parser id ("anthropic", "openai"); empty when the
+	// proxy dispatches the provider by URL path instead.
+	APIFlavor string
+	// AllModelsAllowed is true when no model allowlist restricts this
+	// provider for the caller. Models then lists the declared/catalog
+	// models as a courtesy (possibly none for gateway-style providers).
+	AllModelsAllowed bool
+	// Models is the effective model allowlist for the caller, or the
+	// declared/catalog models when AllModelsAllowed is true.
+	Models []string
+}

management/internals/server/boot.go

@@ -211,10 +211,12 @@ func (s *BaseServer) GRPCServer() *grpc.Server {
 		}
 		serviceMgr := s.ServiceManager()
 		srv.SetReverseProxyManager(serviceMgr)
+		srv.SetAgentNetworkSetupService(s.AgentNetworkManager())
 		if serviceMgr != nil {
 			serviceMgr.StartExposeReaper(context.Background())
 		}
 		mgmtProto.RegisterManagementServiceServer(gRPCAPIHandler, srv)
+		log.Info("ManagementService registered on gRPC server (agent-network setup RPC available)")
 
 		mgmtProto.RegisterProxyServiceServer(gRPCAPIHandler, s.ReverseProxyGRPCServer())
 		log.Info("ProxyService registered on gRPC server")

management/internals/shared/grpc/agentnetwork_service.go

@@ -0,0 +1,81 @@
+package grpc
+
+import (
+	"context"
+
+	log "github.com/sirupsen/logrus"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	antypes "github.com/netbirdio/netbird/management/internals/modules/agentnetwork/types"
+	"github.com/netbirdio/netbird/shared/management/proto"
+)
+
+// AgentNetworkSetupService is the minimal slice of agentnetwork.Manager
+// the peer-facing setup RPC needs. Narrow on purpose so the gRPC server
+// never sees the manager's operator-facing surface.
+type AgentNetworkSetupService interface {
+	GetSetupForPeer(ctx context.Context, accountID, peerID string) (*antypes.EffectiveSetup, error)
+}
+
+// GetAgentNetworkSetup handles a peer request for its Agent Network
+// connection info. The WireGuard key is the credential (same trust model
+// as the Expose RPCs); the response is scoped to what the calling peer's
+// own groups authorize and carries display metadata only.
+func (s *Server) GetAgentNetworkSetup(ctx context.Context, req *proto.EncryptedMessage) (*proto.EncryptedMessage, error) {
+	setupReq := &proto.AgentNetworkSetupRequest{}
+	peerKey, err := s.parseRequest(ctx, req, setupReq)
+	if err != nil {
+		return nil, err
+	}
+
+	accountID, peer, err := s.authenticateExposePeer(ctx, peerKey)
+	if err != nil {
+		return nil, err
+	}
+
+	setupSvc := s.getAgentNetworkSetupService()
+	if setupSvc == nil {
+		return nil, status.Errorf(codes.Internal, "agent network manager not available")
+	}
+
+	setup, err := setupSvc.GetSetupForPeer(ctx, accountID, peer.ID)
+	if err != nil {
+		log.WithContext(ctx).Errorf("get agent network setup for peer %s: %v", peer.ID, err)
+		return nil, status.Errorf(codes.Internal, "internal error")
+	}
+
+	return s.encryptResponse(peerKey, toProtoAgentNetworkSetup(setup))
+}
+
+func toProtoAgentNetworkSetup(setup *antypes.EffectiveSetup) *proto.AgentNetworkSetupResponse {
+	resp := &proto.AgentNetworkSetupResponse{
+		Configured: setup.Configured,
+		Endpoint:   setup.Endpoint,
+		Providers:  make([]*proto.AgentNetworkProviderInfo, 0, len(setup.Providers)),
+	}
+	for _, p := range setup.Providers {
+		resp.Providers = append(resp.Providers, &proto.AgentNetworkProviderInfo{
+			Name:             p.Name,
+			CatalogId:        p.CatalogID,
+			ApiFlavor:        p.APIFlavor,
+			AllModelsAllowed: p.AllModelsAllowed,
+			Models:           p.Models,
+		})
+	}
+	return resp
+}
+
+func (s *Server) getAgentNetworkSetupService() AgentNetworkSetupService {
+	s.agentNetworkSetupMu.RLock()
+	defer s.agentNetworkSetupMu.RUnlock()
+	return s.agentNetworkSetup
+}
+
+// SetAgentNetworkSetupService wires the agent-network setup service on
+// the server.
+func (s *Server) SetAgentNetworkSetupService(svc AgentNetworkSetupService) {
+	s.agentNetworkSetupMu.Lock()
+	defer s.agentNetworkSetupMu.Unlock()
+	s.agentNetworkSetup = svc
+}

management/internals/shared/grpc/server.go

@@ -87,6 +87,9 @@ type Server struct {
 
 	reverseProxyManager rpservice.Manager
 	reverseProxyMu      sync.RWMutex
+
+	agentNetworkSetup   AgentNetworkSetupService
+	agentNetworkSetupMu sync.RWMutex
 }
 
 // NewServer creates a new Management server

management/server/group.go

@@ -6,8 +6,6 @@ import (
 	"fmt"
 	"slices"
 
-	agentNetworkTypes "github.com/netbirdio/netbird/management/internals/modules/agentnetwork/types"
-	"github.com/netbirdio/netbird/management/internals/modules/reverseproxy/service"
 	"github.com/rs/xid"
 	log "github.com/sirupsen/logrus"
 
@@ -746,14 +744,6 @@ func validateDeleteGroup(ctx context.Context, transaction store.Store, group *ty
 		return &GroupLinkError{"network router", linkedRouter.ID}
 	}
 
-	if isLinked, linkedService := isGroupLinkedToReverseProxyService(ctx, transaction, group.AccountID, group.ID); isLinked {
-		return &GroupLinkError{"reverse proxy service", linkedService.Domain}
-	}
-
-	if isLinked, linkedPolicy := isGroupLinkedToAgentNetworkPolicy(ctx, transaction, group.AccountID, group.ID); isLinked {
-		return &GroupLinkError{"agent network policy", linkedPolicy.Name}
-	}
-
 	return checkGroupLinkedToSettings(ctx, transaction, group)
 }
 
@@ -885,46 +875,6 @@ func isGroupLinkedToNetworkRouter(ctx context.Context, transaction store.Store,
 	return false, nil
 }
 
-// isGroupLinkedToReverseProxyService checks if a group is used as an access group
-// of a private reverse proxy service or as a bearer-auth distribution group.
-func isGroupLinkedToReverseProxyService(ctx context.Context, transaction store.Store, accountID string, groupID string) (bool, *service.Service) {
-	services, err := transaction.GetAccountServices(ctx, store.LockingStrengthNone, accountID)
-	if err != nil {
-		log.WithContext(ctx).Errorf("error retrieving reverse proxy services while checking group linkage: %v", err)
-		return false, nil
-	}
-
-	for _, svc := range services {
-		if svc.Private && slices.Contains(svc.AccessGroups, groupID) {
-			return true, svc
-		}
-		if svc.Auth.BearerAuth != nil && svc.Auth.BearerAuth.Enabled && slices.Contains(svc.Auth.BearerAuth.DistributionGroups, groupID) {
-			return true, svc
-		}
-	}
-	return false, nil
-}
-
-// isGroupLinkedToAgentNetworkPolicy checks if a group is used as a source group by any
-// agent network policy in the account.
-func isGroupLinkedToAgentNetworkPolicy(ctx context.Context, transaction store.Store, accountID string, groupID string) (bool, *agentNetworkTypes.Policy) {
-	policies, err := transaction.GetAccountAgentNetworkPolicies(ctx, store.LockingStrengthNone, accountID)
-	if err != nil {
-		log.WithContext(ctx).Errorf("error retrieving agent network policies while checking group linkage: %v", err)
-		return false, nil
-	}
-
-	for _, policy := range policies {
-		if policy == nil {
-			continue
-		}
-		if slices.Contains(policy.SourceGroups, groupID) {
-			return true, policy
-		}
-	}
-	return false, nil
-}
-
 // areGroupChangesAffectPeers checks if any changes to the specified groups will affect peers.
 // It fetches each collection once and checks all groupIDs against them in memory.
 func areGroupChangesAffectPeers(ctx context.Context, transaction store.Store, accountID string, groupIDs []string) (bool, error) {

management/server/group_test.go

@@ -18,8 +18,6 @@ import (
 	"golang.org/x/exp/maps"
 
 	nbdns "github.com/netbirdio/netbird/dns"
-	agentNetworkTypes "github.com/netbirdio/netbird/management/internals/modules/agentnetwork/types"
-	rpservice "github.com/netbirdio/netbird/management/internals/modules/reverseproxy/service"
 	"github.com/netbirdio/netbird/management/server/groups"
 	"github.com/netbirdio/netbird/management/server/networks"
 	"github.com/netbirdio/netbird/management/server/networks/resources"
@@ -127,21 +125,6 @@ func TestDefaultAccountManager_DeleteGroup(t *testing.T) {
 			"grp-for-integration",
 			"only service users with admin power can delete integration group",
 		},
-		{
-			"agent network policy",
-			"grp-for-agent-network-policy",
-			"agent network policy",
-		},
-		{
-			"reverse proxy private service access group",
-			"grp-for-rp-private",
-			"reverse proxy service",
-		},
-		{
-			"reverse proxy bearer distribution group",
-			"grp-for-rp-bearer",
-			"reverse proxy service",
-		},
 	}
 
 	for _, testCase := range testCases {
@@ -235,17 +218,6 @@ func TestDefaultAccountManager_DeleteGroups(t *testing.T) {
 			groupIDs:        []string{"grp-for-integration"},
 			expectedReasons: []string{"only service users with admin power can delete integration group"},
 		},
-		{
-			name:            "agent network policy",
-			groupIDs:        []string{"grp-for-agent-network-policy"},
-			expectedReasons: []string{"agent network policy"},
-		},
-		{
-			name:               "reverse proxy services",
-			groupIDs:           []string{"grp-for-rp-private", "grp-for-rp-bearer"},
-			expectedReasons:    []string{"reverse proxy service", "reverse proxy service"},
-			expectedNotDeleted: []string{"grp-for-rp-private", "grp-for-rp-bearer"},
-		},
 		{
 			name:            "successfully delete multiple groups",
 			groupIDs:        []string{"group-1", "group-2"},
@@ -313,65 +285,6 @@ func TestDefaultAccountManager_DeleteGroups(t *testing.T) {
 	}
 }
 
-func TestDefaultAccountManager_DeleteGroupUnlinkedFromReverseProxyService(t *testing.T) {
-	am, _, err := createManager(t)
-	require.NoError(t, err, "Failed to create account manager")
-
-	_, account, err := initTestGroupAccount(am)
-	require.NoError(t, err, "Failed to init testing account")
-
-	deletableGroups := []*types.Group{
-		{
-			ID:        "grp-rp-bearer-disabled",
-			AccountID: account.Id,
-			Name:      "Group only in a disabled bearer auth",
-			Issued:    types.GroupIssuedAPI,
-			Peers:     make([]string, 0),
-		},
-		{
-			ID:        "grp-rp-nonprivate-access",
-			AccountID: account.Id,
-			Name:      "Group only in a non-private service's access groups",
-			Issued:    types.GroupIssuedAPI,
-			Peers:     make([]string, 0),
-		},
-	}
-	for _, group := range deletableGroups {
-		require.NoError(t, am.CreateGroup(context.Background(), account.Id, groupAdminUserID, group))
-	}
-
-	// Disabled bearer auth and stale access groups on a non-private service
-	// are inert configuration and must not block group deletion.
-	services := []*rpservice.Service{
-		{
-			ID:        "rp-svc-bearer-disabled",
-			AccountID: account.Id,
-			Domain:    "bearer-disabled.services.example.com",
-			Auth: rpservice.AuthConfig{
-				BearerAuth: &rpservice.BearerAuthConfig{
-					Enabled:            false,
-					DistributionGroups: []string{"grp-rp-bearer-disabled"},
-				},
-			},
-		},
-		{
-			ID:           "rp-svc-nonprivate-access",
-			AccountID:    account.Id,
-			Domain:       "nonprivate.services.example.com",
-			Private:      false,
-			AccessGroups: []string{"grp-rp-nonprivate-access"},
-		},
-	}
-	for _, svc := range services {
-		require.NoError(t, am.Store.CreateService(context.Background(), svc))
-	}
-
-	for _, group := range deletableGroups {
-		err = am.DeleteGroup(context.Background(), account.Id, groupAdminUserID, group.ID)
-		assert.NoError(t, err, "group %s is not referenced by an active reverse proxy gate and should be deletable", group.ID)
-	}
-}
-
 func TestDefaultAccountManager_DeleteGroupLinkedToFlowGroup(t *testing.T) {
 	am, _, err := createManager(t)
 	require.NoError(t, err)
@@ -493,30 +406,6 @@ func initTestGroupAccount(am *DefaultAccountManager) (*DefaultAccountManager, *t
 		Peers:     make([]string, 0),
 	}
 
-	groupForAgentNetworkPolicy := &types.Group{
-		ID:        "grp-for-agent-network-policy",
-		AccountID: "account-id",
-		Name:      "Group for agent network policies",
-		Issued:    types.GroupIssuedAPI,
-		Peers:     make([]string, 0),
-	}
-
-	groupForRPPrivate := &types.Group{
-		ID:        "grp-for-rp-private",
-		AccountID: "account-id",
-		Name:      "Group for private reverse proxy service",
-		Issued:    types.GroupIssuedAPI,
-		Peers:     make([]string, 0),
-	}
-
-	groupForRPBearer := &types.Group{
-		ID:        "grp-for-rp-bearer",
-		AccountID: "account-id",
-		Name:      "Group for bearer reverse proxy service",
-		Issued:    types.GroupIssuedAPI,
-		Peers:     make([]string, 0),
-	}
-
 	routeResource := &route.Route{
 		ID:     "example route",
 		Groups: []string{groupForRoute.ID},
@@ -572,66 +461,6 @@ func initTestGroupAccount(am *DefaultAccountManager) (*DefaultAccountManager, *t
 	_ = am.CreateGroup(context.Background(), accountID, groupAdminUserID, groupForSetupKeys)
 	_ = am.CreateGroup(context.Background(), accountID, groupAdminUserID, groupForUsers)
 	_ = am.CreateGroup(context.Background(), accountID, groupAdminUserID, groupForIntegration)
-	_ = am.CreateGroup(context.Background(), accountID, groupAdminUserID, groupForAgentNetworkPolicy)
-	_ = am.CreateGroup(context.Background(), accountID, groupAdminUserID, groupForRPPrivate)
-	_ = am.CreateGroup(context.Background(), accountID, groupAdminUserID, groupForRPBearer)
-
-	agentNetworkPolicy := &agentNetworkTypes.Policy{
-		ID:           "example agent network policy",
-		AccountID:    accountID,
-		Name:         "Example agent network policy",
-		Enabled:      true,
-		SourceGroups: []string{groupForAgentNetworkPolicy.ID},
-	}
-	if err := am.Store.SaveAgentNetworkPolicy(context.Background(), agentNetworkPolicy); err != nil {
-		return nil, nil, err
-	}
-
-	// The decoy services are created first so the linkage check has to scan
-	// past services that do not reference the groups under test.
-	rpServices := []*rpservice.Service{
-		{
-			ID:           "rp-svc-private-decoy",
-			AccountID:    accountID,
-			Domain:       "private-decoy.services.example.com",
-			Private:      true,
-			AccessGroups: []string{"unrelated-group"},
-		},
-		{
-			ID:        "rp-svc-bearer-decoy",
-			AccountID: accountID,
-			Domain:    "bearer-decoy.services.example.com",
-			Auth: rpservice.AuthConfig{
-				BearerAuth: &rpservice.BearerAuthConfig{
-					Enabled:            true,
-					DistributionGroups: []string{"unrelated-group"},
-				},
-			},
-		},
-		{
-			ID:           "rp-svc-private",
-			AccountID:    accountID,
-			Domain:       "private.services.example.com",
-			Private:      true,
-			AccessGroups: []string{groupForRPPrivate.ID},
-		},
-		{
-			ID:        "rp-svc-bearer",
-			AccountID: accountID,
-			Domain:    "bearer.services.example.com",
-			Auth: rpservice.AuthConfig{
-				BearerAuth: &rpservice.BearerAuthConfig{
-					Enabled:            true,
-					DistributionGroups: []string{groupForRPBearer.ID},
-				},
-			},
-		},
-	}
-	for _, svc := range rpServices {
-		if err := am.Store.CreateService(context.Background(), svc); err != nil {
-			return nil, nil, err
-		}
-	}
 
 	acc, err := am.Store.GetAccount(context.Background(), account.Id)
 	if err != nil {

management/server/types/account.go

@@ -1707,34 +1707,14 @@ func (a *Account) injectPrivateServicePolicies(svc *service.Service, proxyPeers
 	if len(proxyPeers) == 0 {
 		return
 	}
-	// A service's AccessGroups can name groups that no longer exist — persisted
-	// services and the agent-network synthesiser both carry the ids verbatim from
-	// their own state. An unresolvable source authorises nothing, so drop it here
-	// rather than let the network-map assembly resolve it to a nil group.
-	sources := a.existingGroupIDs(svc.AccessGroups)
-	if len(sources) == 0 {
-		return
-	}
 	for _, proxyPeer := range proxyPeers {
-		a.Policies = append(a.Policies, a.createPrivateServicePolicy(svc, proxyPeer, sources))
+		a.Policies = append(a.Policies, a.createPrivateServicePolicy(svc, proxyPeer))
 	}
 }
 
-// existingGroupIDs returns the subset of groupIDs that resolve to a group in the account,
-// preserving the input order.
-func (a *Account) existingGroupIDs(groupIDs []string) []string {
-	out := make([]string, 0, len(groupIDs))
-	for _, groupID := range groupIDs {
-		if _, ok := a.Groups[groupID]; ok {
-			out = append(out, groupID)
-		}
-	}
-	return out
-}
-
-func (a *Account) createPrivateServicePolicy(svc *service.Service, proxyPeer *nbpeer.Peer, accessGroups []string) *Policy {
+func (a *Account) createPrivateServicePolicy(svc *service.Service, proxyPeer *nbpeer.Peer) *Policy {
 	policyID := fmt.Sprintf("private-access-%s-%s", svc.ID, proxyPeer.ID)
-	sources := append([]string(nil), accessGroups...)
+	sources := append([]string(nil), svc.AccessGroups...)
 	return &Policy{
 		ID:      policyID,
 		Name:    fmt.Sprintf("Private Access to %s", svc.Name),

shared/management/client/agentnetwork_test.go

@@ -0,0 +1,89 @@
+package client
+
+import (
+	"context"
+	"net"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
+	"google.golang.org/grpc"
+
+	"github.com/netbirdio/netbird/encryption"
+	mgmtProto "github.com/netbirdio/netbird/shared/management/proto"
+)
+
+// agentNetworkSetupServer is a minimal ManagementService that answers
+// GetServerKey and GetAgentNetworkSetup with the real NaCl-box envelope,
+// so the test pins the full wire path: gRPC method routing, request
+// encryption, and response decryption.
+type agentNetworkSetupServer struct {
+	mgmtProto.UnimplementedManagementServiceServer
+	key wgtypes.Key
+}
+
+func (s *agentNetworkSetupServer) GetServerKey(_ context.Context, _ *mgmtProto.Empty) (*mgmtProto.ServerKeyResponse, error) {
+	return &mgmtProto.ServerKeyResponse{Key: s.key.PublicKey().String()}, nil
+}
+
+func (s *agentNetworkSetupServer) GetAgentNetworkSetup(_ context.Context, msg *mgmtProto.EncryptedMessage) (*mgmtProto.EncryptedMessage, error) {
+	peerKey, err := wgtypes.ParseKey(msg.WgPubKey)
+	if err != nil {
+		return nil, err
+	}
+	req := &mgmtProto.AgentNetworkSetupRequest{}
+	if err := encryption.DecryptMessage(peerKey, s.key, msg.Body, req); err != nil {
+		return nil, err
+	}
+	resp := &mgmtProto.AgentNetworkSetupResponse{
+		Configured: true,
+		Endpoint:   "https://violet.eu.proxy.example.com",
+		Providers: []*mgmtProto.AgentNetworkProviderInfo{
+			{
+				Name:      "Anthropic prod",
+				CatalogId: "anthropic_api",
+				ApiFlavor: "anthropic",
+				Models:    []string{"claude-sonnet-4-5"},
+			},
+		},
+	}
+	body, err := encryption.EncryptMessage(peerKey, s.key, resp)
+	if err != nil {
+		return nil, err
+	}
+	return &mgmtProto.EncryptedMessage{WgPubKey: s.key.PublicKey().String(), Body: body}, nil
+}
+
+// TestGetAgentNetworkSetup_RoundTrip proves the RPC is routable on any
+// server built from this tree and that the encrypt→invoke→decrypt path
+// the CLI uses round-trips. A server answering this call with
+// codes.Unimplemented is by definition running a binary compiled without
+// the regenerated management proto.
+func TestGetAgentNetworkSetup_RoundTrip(t *testing.T) {
+	serverKey, err := wgtypes.GeneratePrivateKey()
+	require.NoError(t, err)
+
+	lis, err := net.Listen("tcp", "127.0.0.1:0")
+	require.NoError(t, err)
+
+	srv := grpc.NewServer()
+	mgmtProto.RegisterManagementServiceServer(srv, &agentNetworkSetupServer{key: serverKey})
+	go func() { _ = srv.Serve(lis) }()
+	t.Cleanup(srv.Stop)
+
+	clientKey, err := wgtypes.GeneratePrivateKey()
+	require.NoError(t, err)
+
+	client, err := NewClient(context.Background(), lis.Addr().String(), clientKey, false)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = client.Close() })
+
+	setup, err := client.GetAgentNetworkSetup(context.Background())
+	require.NoError(t, err)
+	assert.True(t, setup.Configured)
+	assert.Equal(t, "https://violet.eu.proxy.example.com", setup.Endpoint)
+	require.Len(t, setup.Providers, 1)
+	assert.Equal(t, "anthropic_api", setup.Providers[0].CatalogId)
+	assert.Equal(t, []string{"claude-sonnet-4-5"}, setup.Providers[0].Models)
+}

shared/management/client/client.go

@@ -34,4 +34,8 @@ type Client interface {
 	CreateExpose(ctx context.Context, req ExposeRequest) (*ExposeResponse, error)
 	RenewExpose(ctx context.Context, domain string) error
 	StopExpose(ctx context.Context, domain string) error
+	// GetAgentNetworkSetup returns the Agent Network connection info the
+	// calling peer's groups authorize: proxy endpoint plus effective
+	// providers and models.
+	GetAgentNetworkSetup(ctx context.Context) (*proto.AgentNetworkSetupResponse, error)
 }

shared/management/client/grpc.go

@@ -914,6 +914,38 @@ func (c *GrpcClient) StopExpose(ctx context.Context, domain string) error {
 	return err
 }
 
+// GetAgentNetworkSetup asks the management server for the Agent Network
+// connection info the calling peer's groups authorize.
+func (c *GrpcClient) GetAgentNetworkSetup(ctx context.Context) (*proto.AgentNetworkSetupResponse, error) {
+	serverPubKey, err := c.getServerPublicKey()
+	if err != nil {
+		return nil, err
+	}
+
+	encReq, err := encryption.EncryptMessage(*serverPubKey, c.key, &proto.AgentNetworkSetupRequest{})
+	if err != nil {
+		return nil, fmt.Errorf("encrypt agent network setup request: %w", err)
+	}
+
+	mgmCtx, cancel := context.WithTimeout(ctx, ConnectTimeout)
+	defer cancel()
+
+	resp, err := c.realClient.GetAgentNetworkSetup(mgmCtx, &proto.EncryptedMessage{
+		WgPubKey: c.key.PublicKey().String(),
+		Body:     encReq,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	setupResp := &proto.AgentNetworkSetupResponse{}
+	if err := encryption.DecryptMessage(*serverPubKey, c.key, resp.Body, setupResp); err != nil {
+		return nil, fmt.Errorf("decrypt agent network setup response: %w", err)
+	}
+
+	return setupResp, nil
+}
+
 func fromProtoExposeResponse(resp *proto.ExposeServiceResponse) *ExposeResponse {
 	return &ExposeResponse{
 		ServiceName:      resp.ServiceName,

shared/management/client/mock.go

@@ -25,6 +25,7 @@ type MockClient struct {
 	CreateExposeFunc               func(ctx context.Context, req ExposeRequest) (*ExposeResponse, error)
 	RenewExposeFunc                func(ctx context.Context, domain string) error
 	StopExposeFunc                 func(ctx context.Context, domain string) error
+	GetAgentNetworkSetupFunc       func(ctx context.Context) (*proto.AgentNetworkSetupResponse, error)
 }
 
 func (m *MockClient) IsHealthy() bool {
@@ -136,3 +137,10 @@ func (m *MockClient) StopExpose(ctx context.Context, domain string) error {
 	}
 	return m.StopExposeFunc(ctx, domain)
 }
+
+func (m *MockClient) GetAgentNetworkSetup(ctx context.Context) (*proto.AgentNetworkSetupResponse, error) {
+	if m.GetAgentNetworkSetupFunc == nil {
+		return &proto.AgentNetworkSetupResponse{}, nil
+	}
+	return m.GetAgentNetworkSetupFunc(ctx)
+}

shared/management/proto/management.pb.go

@@ -6653,6 +6653,201 @@ func (x *PeerIndexSet) GetPeerIndexes() []uint32 {
 	return nil
 }
 
+type AgentNetworkSetupRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *AgentNetworkSetupRequest) Reset() {
+	*x = AgentNetworkSetupRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_management_proto_msgTypes[76]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *AgentNetworkSetupRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AgentNetworkSetupRequest) ProtoMessage() {}
+
+func (x *AgentNetworkSetupRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_management_proto_msgTypes[76]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use AgentNetworkSetupRequest.ProtoReflect.Descriptor instead.
+func (*AgentNetworkSetupRequest) Descriptor() ([]byte, []int) {
+	return file_management_proto_rawDescGZIP(), []int{76}
+}
+
+type AgentNetworkSetupResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// configured is false when the account has no Agent Network set up or
+	// the calling peer's groups authorize none of it — the two cases are
+	// deliberately indistinguishable.
+	Configured bool `protobuf:"varint,1,opt,name=configured,proto3" json:"configured,omitempty"`
+	// endpoint is the account's proxy base URL, e.g.
+	// "https://calm-otter.proxy.example.com". Reachable over the NetBird
+	// tunnel only. Empty when configured is false.
+	Endpoint  string                      `protobuf:"bytes,2,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
+	Providers []*AgentNetworkProviderInfo `protobuf:"bytes,3,rep,name=providers,proto3" json:"providers,omitempty"`
+}
+
+func (x *AgentNetworkSetupResponse) Reset() {
+	*x = AgentNetworkSetupResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_management_proto_msgTypes[77]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *AgentNetworkSetupResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AgentNetworkSetupResponse) ProtoMessage() {}
+
+func (x *AgentNetworkSetupResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_management_proto_msgTypes[77]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use AgentNetworkSetupResponse.ProtoReflect.Descriptor instead.
+func (*AgentNetworkSetupResponse) Descriptor() ([]byte, []int) {
+	return file_management_proto_rawDescGZIP(), []int{77}
+}
+
+func (x *AgentNetworkSetupResponse) GetConfigured() bool {
+	if x != nil {
+		return x.Configured
+	}
+	return false
+}
+
+func (x *AgentNetworkSetupResponse) GetEndpoint() string {
+	if x != nil {
+		return x.Endpoint
+	}
+	return ""
+}
+
+func (x *AgentNetworkSetupResponse) GetProviders() []*AgentNetworkProviderInfo {
+	if x != nil {
+		return x.Providers
+	}
+	return nil
+}
+
+type AgentNetworkProviderInfo struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// name is the operator-assigned provider label, e.g. "Bedrock prod".
+	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	// catalog_id names the catalog entry, e.g. "anthropic_api", "bedrock_api".
+	CatalogId string `protobuf:"bytes,2,opt,name=catalog_id,json=catalogId,proto3" json:"catalog_id,omitempty"`
+	// api_flavor is the request-body shape the provider speaks ("anthropic",
+	// "openai"); empty when the proxy dispatches it by URL path instead.
+	ApiFlavor string `protobuf:"bytes,3,opt,name=api_flavor,json=apiFlavor,proto3" json:"api_flavor,omitempty"`
+	// all_models_allowed is true when no model allowlist restricts this
+	// provider for the caller; models then lists the declared/catalog models
+	// as a courtesy (possibly none for gateway-style providers).
+	AllModelsAllowed bool `protobuf:"varint,4,opt,name=all_models_allowed,json=allModelsAllowed,proto3" json:"all_models_allowed,omitempty"`
+	// models is the effective model allowlist for the caller (or the
+	// declared/catalog models when all_models_allowed is true).
+	Models []string `protobuf:"bytes,5,rep,name=models,proto3" json:"models,omitempty"`
+}
+
+func (x *AgentNetworkProviderInfo) Reset() {
+	*x = AgentNetworkProviderInfo{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_management_proto_msgTypes[78]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *AgentNetworkProviderInfo) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AgentNetworkProviderInfo) ProtoMessage() {}
+
+func (x *AgentNetworkProviderInfo) ProtoReflect() protoreflect.Message {
+	mi := &file_management_proto_msgTypes[78]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use AgentNetworkProviderInfo.ProtoReflect.Descriptor instead.
+func (*AgentNetworkProviderInfo) Descriptor() ([]byte, []int) {
+	return file_management_proto_rawDescGZIP(), []int{78}
+}
+
+func (x *AgentNetworkProviderInfo) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *AgentNetworkProviderInfo) GetCatalogId() string {
+	if x != nil {
+		return x.CatalogId
+	}
+	return ""
+}
+
+func (x *AgentNetworkProviderInfo) GetApiFlavor() string {
+	if x != nil {
+		return x.ApiFlavor
+	}
+	return ""
+}
+
+func (x *AgentNetworkProviderInfo) GetAllModelsAllowed() bool {
+	if x != nil {
+		return x.AllModelsAllowed
+	}
+	return false
+}
+
+func (x *AgentNetworkProviderInfo) GetModels() []string {
+	if x != nil {
+		return x.Models
+	}
+	return nil
+}
+
 type PortInfo_Range struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -6665,7 +6860,7 @@ type PortInfo_Range struct {
 func (x *PortInfo_Range) Reset() {
 	*x = PortInfo_Range{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_management_proto_msgTypes[77]
+		mi := &file_management_proto_msgTypes[80]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -6678,7 +6873,7 @@ func (x *PortInfo_Range) String() string {
 func (*PortInfo_Range) ProtoMessage() {}
 
 func (x *PortInfo_Range) ProtoReflect() protoreflect.Message {
-	mi := &file_management_proto_msgTypes[77]
+	mi := &file_management_proto_msgTypes[80]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -7744,99 +7939,127 @@ var file_management_proto_rawDesc = []byte{
 	0x0c, 0x50, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x53, 0x65, 0x74, 0x12, 0x21, 0x0a,
 	0x0c, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x73, 0x18, 0x01, 0x20,
 	0x03, 0x28, 0x0d, 0x52, 0x0b, 0x70, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x73,
-	0x2a, 0x3a, 0x0a, 0x09, 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x12, 0x0a,
-	0x0e, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x10,
-	0x00, 0x12, 0x0d, 0x0a, 0x09, 0x73, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x10, 0x01,
-	0x12, 0x0a, 0x0a, 0x06, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x10, 0x02, 0x2a, 0x93, 0x01, 0x0a,
-	0x0e, 0x50, 0x65, 0x65, 0x72, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12,
-	0x19, 0x0a, 0x15, 0x50, 0x65, 0x65, 0x72, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74,
-	0x79, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x10, 0x00, 0x12, 0x20, 0x0a, 0x1c, 0x50, 0x65,
-	0x65, 0x72, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x53, 0x6f, 0x75, 0x72,
-	0x63, 0x65, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x65, 0x73, 0x10, 0x01, 0x12, 0x1d, 0x0a, 0x19,
-	0x50, 0x65, 0x65, 0x72, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x49, 0x50,
-	0x76, 0x36, 0x4f, 0x76, 0x65, 0x72, 0x6c, 0x61, 0x79, 0x10, 0x02, 0x12, 0x25, 0x0a, 0x21, 0x50,
-	0x65, 0x65, 0x72, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6d,
-	0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x4d, 0x61, 0x70,
-	0x10, 0x03, 0x2a, 0x5d, 0x0a, 0x0c, 0x52, 0x75, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63,
-	0x6f, 0x6c, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12,
-	0x07, 0x0a, 0x03, 0x41, 0x4c, 0x4c, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x54, 0x43, 0x50, 0x10,
-	0x02, 0x12, 0x07, 0x0a, 0x03, 0x55, 0x44, 0x50, 0x10, 0x03, 0x12, 0x08, 0x0a, 0x04, 0x49, 0x43,
-	0x4d, 0x50, 0x10, 0x04, 0x12, 0x0a, 0x0a, 0x06, 0x43, 0x55, 0x53, 0x54, 0x4f, 0x4d, 0x10, 0x05,
-	0x12, 0x0f, 0x0a, 0x0b, 0x4e, 0x45, 0x54, 0x42, 0x49, 0x52, 0x44, 0x5f, 0x53, 0x53, 0x48, 0x10,
-	0x06, 0x2a, 0x20, 0x0a, 0x0d, 0x52, 0x75, 0x6c, 0x65, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69,
-	0x6f, 0x6e, 0x12, 0x06, 0x0a, 0x02, 0x49, 0x4e, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x4f, 0x55,
-	0x54, 0x10, 0x01, 0x2a, 0x22, 0x0a, 0x0a, 0x52, 0x75, 0x6c, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f,
-	0x6e, 0x12, 0x0a, 0x0a, 0x06, 0x41, 0x43, 0x43, 0x45, 0x50, 0x54, 0x10, 0x00, 0x12, 0x08, 0x0a,
-	0x04, 0x44, 0x52, 0x4f, 0x50, 0x10, 0x01, 0x2a, 0x63, 0x0a, 0x0e, 0x45, 0x78, 0x70, 0x6f, 0x73,
-	0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x12, 0x0f, 0x0a, 0x0b, 0x45, 0x58, 0x50,
-	0x4f, 0x53, 0x45, 0x5f, 0x48, 0x54, 0x54, 0x50, 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c, 0x45, 0x58,
-	0x50, 0x4f, 0x53, 0x45, 0x5f, 0x48, 0x54, 0x54, 0x50, 0x53, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a,
-	0x45, 0x58, 0x50, 0x4f, 0x53, 0x45, 0x5f, 0x54, 0x43, 0x50, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a,
-	0x45, 0x58, 0x50, 0x4f, 0x53, 0x45, 0x5f, 0x55, 0x44, 0x50, 0x10, 0x03, 0x12, 0x0e, 0x0a, 0x0a,
-	0x45, 0x58, 0x50, 0x4f, 0x53, 0x45, 0x5f, 0x54, 0x4c, 0x53, 0x10, 0x04, 0x32, 0xd0, 0x07, 0x0a,
-	0x11, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69,
-	0x63, 0x65, 0x12, 0x45, 0x0a, 0x05, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x12, 0x1c, 0x2e, 0x6d, 0x61,
-	0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74,
-	0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61,
-	0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x12, 0x46, 0x0a, 0x04, 0x53, 0x79, 0x6e,
-	0x63, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45,
-	0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a,
-	0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63,
-	0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x30,
-	0x01, 0x12, 0x42, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x4b, 0x65,
-	0x79, 0x12, 0x11, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45,
-	0x6d, 0x70, 0x74, 0x79, 0x1a, 0x1d, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e,
-	0x74, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x33, 0x0a, 0x09, 0x69, 0x73, 0x48, 0x65, 0x61, 0x6c, 0x74,
-	0x68, 0x79, 0x12, 0x11, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e,
-	0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x11, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65,
-	0x6e, 0x74, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x1a, 0x47, 0x65,
-	0x74, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x46, 0x6c, 0x6f, 0x77, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67,
-	0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d,
-	0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x12, 0x58, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x50, 0x4b, 0x43,
-	0x45, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x6c,
-	0x6f, 0x77, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e,
-	0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x1a, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e,
-	0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00,
-	0x12, 0x3d, 0x0a, 0x08, 0x53, 0x79, 0x6e, 0x63, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x1c, 0x2e, 0x6d,
-	0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70,
-	0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x11, 0x2e, 0x6d, 0x61, 0x6e,
-	0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12,
-	0x3b, 0x0a, 0x06, 0x4c, 0x6f, 0x67, 0x6f, 0x75, 0x74, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61,
-	0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x11, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65,
-	0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x47, 0x0a, 0x03,
-	0x4a, 0x6f, 0x62, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74,
-	0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x1a, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45,
-	0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22,
-	0x00, 0x28, 0x01, 0x30, 0x01, 0x12, 0x51, 0x0a, 0x11, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x41,
-	0x75, 0x74, 0x68, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e,
+	0x22, 0x1a, 0x0a, 0x18, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b,
+	0x53, 0x65, 0x74, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x9b, 0x01, 0x0a,
+	0x19, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x53, 0x65, 0x74,
+	0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6f,
+	0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x6e,
+	0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e,
+	0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x42, 0x0a, 0x09, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64,
+	0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6d, 0x61, 0x6e, 0x61,
+	0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x4e, 0x65, 0x74, 0x77,
+	0x6f, 0x72, 0x6b, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52,
+	0x09, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x22, 0xb2, 0x01, 0x0a, 0x18, 0x41,
+	0x67, 0x65, 0x6e, 0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x50, 0x72, 0x6f, 0x76, 0x69,
+	0x64, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x63,
+	0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x70,
+	0x69, 0x5f, 0x66, 0x6c, 0x61, 0x76, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x61, 0x70, 0x69, 0x46, 0x6c, 0x61, 0x76, 0x6f, 0x72, 0x12, 0x2c, 0x0a, 0x12, 0x61, 0x6c, 0x6c,
+	0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x61, 0x6c, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73,
+	0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
+	0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2a,
+	0x3a, 0x0a, 0x09, 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x12, 0x0a, 0x0e,
+	0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x10, 0x00,
+	0x12, 0x0d, 0x0a, 0x09, 0x73, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x10, 0x01, 0x12,
+	0x0a, 0x0a, 0x06, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x10, 0x02, 0x2a, 0x93, 0x01, 0x0a, 0x0e,
+	0x50, 0x65, 0x65, 0x72, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x19,
+	0x0a, 0x15, 0x50, 0x65, 0x65, 0x72, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79,
+	0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x10, 0x00, 0x12, 0x20, 0x0a, 0x1c, 0x50, 0x65, 0x65,
+	0x72, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x53, 0x6f, 0x75, 0x72, 0x63,
+	0x65, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x65, 0x73, 0x10, 0x01, 0x12, 0x1d, 0x0a, 0x19, 0x50,
+	0x65, 0x65, 0x72, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x49, 0x50, 0x76,
+	0x36, 0x4f, 0x76, 0x65, 0x72, 0x6c, 0x61, 0x79, 0x10, 0x02, 0x12, 0x25, 0x0a, 0x21, 0x50, 0x65,
+	0x65, 0x72, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6d, 0x70,
+	0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x4d, 0x61, 0x70, 0x10,
+	0x03, 0x2a, 0x5d, 0x0a, 0x0c, 0x52, 0x75, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f,
+	0x6c, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x07,
+	0x0a, 0x03, 0x41, 0x4c, 0x4c, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x54, 0x43, 0x50, 0x10, 0x02,
+	0x12, 0x07, 0x0a, 0x03, 0x55, 0x44, 0x50, 0x10, 0x03, 0x12, 0x08, 0x0a, 0x04, 0x49, 0x43, 0x4d,
+	0x50, 0x10, 0x04, 0x12, 0x0a, 0x0a, 0x06, 0x43, 0x55, 0x53, 0x54, 0x4f, 0x4d, 0x10, 0x05, 0x12,
+	0x0f, 0x0a, 0x0b, 0x4e, 0x45, 0x54, 0x42, 0x49, 0x52, 0x44, 0x5f, 0x53, 0x53, 0x48, 0x10, 0x06,
+	0x2a, 0x20, 0x0a, 0x0d, 0x52, 0x75, 0x6c, 0x65, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f,
+	0x6e, 0x12, 0x06, 0x0a, 0x02, 0x49, 0x4e, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x4f, 0x55, 0x54,
+	0x10, 0x01, 0x2a, 0x22, 0x0a, 0x0a, 0x52, 0x75, 0x6c, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+	0x12, 0x0a, 0x0a, 0x06, 0x41, 0x43, 0x43, 0x45, 0x50, 0x54, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04,
+	0x44, 0x52, 0x4f, 0x50, 0x10, 0x01, 0x2a, 0x63, 0x0a, 0x0e, 0x45, 0x78, 0x70, 0x6f, 0x73, 0x65,
+	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x12, 0x0f, 0x0a, 0x0b, 0x45, 0x58, 0x50, 0x4f,
+	0x53, 0x45, 0x5f, 0x48, 0x54, 0x54, 0x50, 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c, 0x45, 0x58, 0x50,
+	0x4f, 0x53, 0x45, 0x5f, 0x48, 0x54, 0x54, 0x50, 0x53, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x45,
+	0x58, 0x50, 0x4f, 0x53, 0x45, 0x5f, 0x54, 0x43, 0x50, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x45,
+	0x58, 0x50, 0x4f, 0x53, 0x45, 0x5f, 0x55, 0x44, 0x50, 0x10, 0x03, 0x12, 0x0e, 0x0a, 0x0a, 0x45,
+	0x58, 0x50, 0x4f, 0x53, 0x45, 0x5f, 0x54, 0x4c, 0x53, 0x10, 0x04, 0x32, 0xa6, 0x08, 0x0a, 0x11,
+	0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
+	0x65, 0x12, 0x45, 0x0a, 0x05, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e,
 	0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65,
 	0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67,
 	0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x12, 0x4c, 0x0a, 0x0c, 0x43, 0x72, 0x65, 0x61,
-	0x74, 0x65, 0x45, 0x78, 0x70, 0x6f, 0x73, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67,
-	0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d,
-	0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x12, 0x4b, 0x0a, 0x0b, 0x52, 0x65, 0x6e, 0x65, 0x77, 0x45,
-	0x78, 0x70, 0x6f, 0x73, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x12, 0x46, 0x0a, 0x04, 0x53, 0x79, 0x6e, 0x63,
+	0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e,
+	0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x1c,
+	0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72,
+	0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x30, 0x01,
+	0x12, 0x42, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x4b, 0x65, 0x79,
+	0x12, 0x11, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x1a, 0x1d, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74,
+	0x2e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x00, 0x12, 0x33, 0x0a, 0x09, 0x69, 0x73, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68,
+	0x79, 0x12, 0x11, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x1a, 0x11, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e,
+	0x74, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x1a, 0x47, 0x65, 0x74,
+	0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x46, 0x6c, 0x6f, 0x77, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65,
+	0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65,
 	0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73,
-	0x61, 0x67, 0x65, 0x1a, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74,
-	0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x22, 0x00, 0x12, 0x4a, 0x0a, 0x0a, 0x53, 0x74, 0x6f, 0x70, 0x45, 0x78, 0x70, 0x6f, 0x73,
-	0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45,
+	0x61, 0x67, 0x65, 0x22, 0x00, 0x12, 0x58, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x50, 0x4b, 0x43, 0x45,
+	0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x6c, 0x6f,
+	0x77, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45,
 	0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a,
 	0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63,
-	0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x42,
-	0x08, 0x5a, 0x06, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x33,
+	0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x12,
+	0x3d, 0x0a, 0x08, 0x53, 0x79, 0x6e, 0x63, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x1c, 0x2e, 0x6d, 0x61,
+	0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74,
+	0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x11, 0x2e, 0x6d, 0x61, 0x6e, 0x61,
+	0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x3b,
+	0x0a, 0x06, 0x4c, 0x6f, 0x67, 0x6f, 0x75, 0x74, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67,
+	0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x11, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d,
+	0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x47, 0x0a, 0x03, 0x4a,
+	0x6f, 0x62, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e,
+	0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x1a, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e,
+	0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00,
+	0x28, 0x01, 0x30, 0x01, 0x12, 0x51, 0x0a, 0x11, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x41, 0x75,
+	0x74, 0x68, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61,
+	0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65,
+	0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x12, 0x4c, 0x0a, 0x0c, 0x43, 0x72, 0x65, 0x61, 0x74,
+	0x65, 0x45, 0x78, 0x70, 0x6f, 0x73, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65,
+	0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65,
+	0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x22, 0x00, 0x12, 0x4b, 0x0a, 0x0b, 0x52, 0x65, 0x6e, 0x65, 0x77, 0x45, 0x78,
+	0x70, 0x6f, 0x73, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e,
+	0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x1a, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e,
+	0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x22, 0x00, 0x12, 0x4a, 0x0a, 0x0a, 0x53, 0x74, 0x6f, 0x70, 0x45, 0x78, 0x70, 0x6f, 0x73, 0x65,
+	0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e,
+	0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x1c,
+	0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72,
+	0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x12, 0x54,
+	0x0a, 0x14, 0x47, 0x65, 0x74, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72,
+	0x6b, 0x53, 0x65, 0x74, 0x75, 0x70, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d,
+	0x65, 0x6e, 0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x1a, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e,
+	0x74, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x22, 0x00, 0x42, 0x08, 0x5a, 0x06, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x06,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -7852,7 +8075,7 @@ func file_management_proto_rawDescGZIP() []byte {
 }
 
 var file_management_proto_enumTypes = make([]protoimpl.EnumInfo, 8)
-var file_management_proto_msgTypes = make([]protoimpl.MessageInfo, 83)
+var file_management_proto_msgTypes = make([]protoimpl.MessageInfo, 86)
 var file_management_proto_goTypes = []interface{}{
 	(JobStatus)(0),                         // 0: management.JobStatus
 	(PeerCapability)(0),                    // 1: management.PeerCapability
@@ -7938,15 +8161,18 @@ var file_management_proto_goTypes = []interface{}{
 	(*PolicyIds)(nil),                      // 81: management.PolicyIds
 	(*UserIDList)(nil),                     // 82: management.UserIDList
 	(*PeerIndexSet)(nil),                   // 83: management.PeerIndexSet
-	nil,                                    // 84: management.SSHAuth.MachineUsersEntry
-	(*PortInfo_Range)(nil),                 // 85: management.PortInfo.Range
-	nil,                                    // 86: management.NetworkMapComponentsFull.RoutersMapEntry
-	nil,                                    // 87: management.NetworkMapComponentsFull.ResourcePoliciesMapEntry
-	nil,                                    // 88: management.NetworkMapComponentsFull.GroupIdToUserIdsEntry
-	nil,                                    // 89: management.NetworkMapComponentsFull.PostureFailedPeersEntry
-	nil,                                    // 90: management.PolicyCompact.AuthorizedGroupsEntry
-	(*timestamppb.Timestamp)(nil),          // 91: google.protobuf.Timestamp
-	(*durationpb.Duration)(nil),            // 92: google.protobuf.Duration
+	(*AgentNetworkSetupRequest)(nil),       // 84: management.AgentNetworkSetupRequest
+	(*AgentNetworkSetupResponse)(nil),      // 85: management.AgentNetworkSetupResponse
+	(*AgentNetworkProviderInfo)(nil),       // 86: management.AgentNetworkProviderInfo
+	nil,                                    // 87: management.SSHAuth.MachineUsersEntry
+	(*PortInfo_Range)(nil),                 // 88: management.PortInfo.Range
+	nil,                                    // 89: management.NetworkMapComponentsFull.RoutersMapEntry
+	nil,                                    // 90: management.NetworkMapComponentsFull.ResourcePoliciesMapEntry
+	nil,                                    // 91: management.NetworkMapComponentsFull.GroupIdToUserIdsEntry
+	nil,                                    // 92: management.NetworkMapComponentsFull.PostureFailedPeersEntry
+	nil,                                    // 93: management.PolicyCompact.AuthorizedGroupsEntry
+	(*timestamppb.Timestamp)(nil),          // 94: google.protobuf.Timestamp
+	(*durationpb.Duration)(nil),            // 95: google.protobuf.Duration
 }
 var file_management_proto_depIdxs = []int32{
 	11,  // 0: management.JobRequest.bundle:type_name -> management.BundleParameters
@@ -7958,7 +8184,7 @@ var file_management_proto_depIdxs = []int32{
 	39,  // 6: management.SyncResponse.remotePeers:type_name -> management.RemotePeerConfig
 	36,  // 7: management.SyncResponse.NetworkMap:type_name -> management.NetworkMap
 	54,  // 8: management.SyncResponse.Checks:type_name -> management.Checks
-	91,  // 9: management.SyncResponse.sessionExpiresAt:type_name -> google.protobuf.Timestamp
+	94,  // 9: management.SyncResponse.sessionExpiresAt:type_name -> google.protobuf.Timestamp
 	64,  // 10: management.SyncResponse.NetworkMapEnvelope:type_name -> management.NetworkMapEnvelope
 	21,  // 11: management.SyncMetaRequest.meta:type_name -> management.PeerSystemMeta
 	21,  // 12: management.LoginRequest.meta:type_name -> management.PeerSystemMeta
@@ -7971,10 +8197,10 @@ var file_management_proto_depIdxs = []int32{
 	27,  // 19: management.LoginResponse.netbirdConfig:type_name -> management.NetbirdConfig
 	34,  // 20: management.LoginResponse.peerConfig:type_name -> management.PeerConfig
 	54,  // 21: management.LoginResponse.Checks:type_name -> management.Checks
-	91,  // 22: management.LoginResponse.sessionExpiresAt:type_name -> google.protobuf.Timestamp
+	94,  // 22: management.LoginResponse.sessionExpiresAt:type_name -> google.protobuf.Timestamp
 	21,  // 23: management.ExtendAuthSessionRequest.meta:type_name -> management.PeerSystemMeta
-	91,  // 24: management.ExtendAuthSessionResponse.sessionExpiresAt:type_name -> google.protobuf.Timestamp
-	91,  // 25: management.ServerKeyResponse.expiresAt:type_name -> google.protobuf.Timestamp
+	94,  // 24: management.ExtendAuthSessionResponse.sessionExpiresAt:type_name -> google.protobuf.Timestamp
+	94,  // 25: management.ServerKeyResponse.expiresAt:type_name -> google.protobuf.Timestamp
 	28,  // 26: management.NetbirdConfig.stuns:type_name -> management.HostConfig
 	33,  // 27: management.NetbirdConfig.turns:type_name -> management.ProtectedHostConfig
 	28,  // 28: management.NetbirdConfig.signal:type_name -> management.HostConfig
@@ -7982,7 +8208,7 @@ var file_management_proto_depIdxs = []int32{
 	30,  // 30: management.NetbirdConfig.flow:type_name -> management.FlowConfig
 	31,  // 31: management.NetbirdConfig.metrics:type_name -> management.MetricsConfig
 	6,   // 32: management.HostConfig.protocol:type_name -> management.HostConfig.Protocol
-	92,  // 33: management.FlowConfig.interval:type_name -> google.protobuf.Duration
+	95,  // 33: management.FlowConfig.interval:type_name -> google.protobuf.Duration
 	28,  // 34: management.ProtectedHostConfig.hostConfig:type_name -> management.HostConfig
 	40,  // 35: management.PeerConfig.sshConfig:type_name -> management.SSHConfig
 	35,  // 36: management.PeerConfig.autoUpdate:type_name -> management.AutoUpdateSettings
@@ -7995,7 +8221,7 @@ var file_management_proto_depIdxs = []int32{
 	56,  // 43: management.NetworkMap.routesFirewallRules:type_name -> management.RouteFirewallRule
 	57,  // 44: management.NetworkMap.forwardingRules:type_name -> management.ForwardingRule
 	37,  // 45: management.NetworkMap.sshAuth:type_name -> management.SSHAuth
-	84,  // 46: management.SSHAuth.machine_users:type_name -> management.SSHAuth.MachineUsersEntry
+	87,  // 46: management.SSHAuth.machine_users:type_name -> management.SSHAuth.MachineUsersEntry
 	40,  // 47: management.RemotePeerConfig.sshConfig:type_name -> management.SSHConfig
 	32,  // 48: management.SSHConfig.jwtConfig:type_name -> management.JWTConfig
 	7,   // 49: management.DeviceAuthorizationFlow.Provider:type_name -> management.DeviceAuthorizationFlow.provider
@@ -8009,7 +8235,7 @@ var file_management_proto_depIdxs = []int32{
 	4,   // 57: management.FirewallRule.Action:type_name -> management.RuleAction
 	2,   // 58: management.FirewallRule.Protocol:type_name -> management.RuleProtocol
 	55,  // 59: management.FirewallRule.PortInfo:type_name -> management.PortInfo
-	85,  // 60: management.PortInfo.range:type_name -> management.PortInfo.Range
+	88,  // 60: management.PortInfo.range:type_name -> management.PortInfo.Range
 	4,   // 61: management.RouteFirewallRule.action:type_name -> management.RuleAction
 	2,   // 62: management.RouteFirewallRule.protocol:type_name -> management.RuleProtocol
 	55,  // 63: management.RouteFirewallRule.portInfo:type_name -> management.PortInfo
@@ -8031,10 +8257,10 @@ var file_management_proto_depIdxs = []int32{
 	49,  // 79: management.NetworkMapComponentsFull.all_dns_records:type_name -> management.SimpleRecord
 	48,  // 80: management.NetworkMapComponentsFull.account_zones:type_name -> management.CustomZone
 	78,  // 81: management.NetworkMapComponentsFull.network_resources:type_name -> management.NetworkResourceRaw
-	86,  // 82: management.NetworkMapComponentsFull.routers_map:type_name -> management.NetworkMapComponentsFull.RoutersMapEntry
-	87,  // 83: management.NetworkMapComponentsFull.resource_policies_map:type_name -> management.NetworkMapComponentsFull.ResourcePoliciesMapEntry
-	88,  // 84: management.NetworkMapComponentsFull.group_id_to_user_ids:type_name -> management.NetworkMapComponentsFull.GroupIdToUserIdsEntry
-	89,  // 85: management.NetworkMapComponentsFull.posture_failed_peers:type_name -> management.NetworkMapComponentsFull.PostureFailedPeersEntry
+	89,  // 82: management.NetworkMapComponentsFull.routers_map:type_name -> management.NetworkMapComponentsFull.RoutersMapEntry
+	90,  // 83: management.NetworkMapComponentsFull.resource_policies_map:type_name -> management.NetworkMapComponentsFull.ResourcePoliciesMapEntry
+	91,  // 84: management.NetworkMapComponentsFull.group_id_to_user_ids:type_name -> management.NetworkMapComponentsFull.GroupIdToUserIdsEntry
+	92,  // 85: management.NetworkMapComponentsFull.posture_failed_peers:type_name -> management.NetworkMapComponentsFull.PostureFailedPeersEntry
 	66,  // 86: management.NetworkMapComponentsFull.proxy_patch:type_name -> management.ProxyPatch
 	39,  // 87: management.ProxyPatch.peers:type_name -> management.RemotePeerConfig
 	39,  // 88: management.ProxyPatch.offline_peers:type_name -> management.RemotePeerConfig
@@ -8044,49 +8270,52 @@ var file_management_proto_depIdxs = []int32{
 	57,  // 92: management.ProxyPatch.forwarding_rules:type_name -> management.ForwardingRule
 	4,   // 93: management.PolicyCompact.action:type_name -> management.RuleAction
 	2,   // 94: management.PolicyCompact.protocol:type_name -> management.RuleProtocol
-	85,  // 95: management.PolicyCompact.port_ranges:type_name -> management.PortInfo.Range
-	90,  // 96: management.PolicyCompact.authorized_groups:type_name -> management.PolicyCompact.AuthorizedGroupsEntry
+	88,  // 95: management.PolicyCompact.port_ranges:type_name -> management.PortInfo.Range
+	93,  // 96: management.PolicyCompact.authorized_groups:type_name -> management.PolicyCompact.AuthorizedGroupsEntry
 	72,  // 97: management.PolicyCompact.source_resource:type_name -> management.ResourceCompact
 	72,  // 98: management.PolicyCompact.destination_resource:type_name -> management.ResourceCompact
 	51,  // 99: management.NameServerGroupRaw.nameservers:type_name -> management.NameServer
 	80,  // 100: management.NetworkRouterList.entries:type_name -> management.NetworkRouterEntry
-	38,  // 101: management.SSHAuth.MachineUsersEntry.value:type_name -> management.MachineUserIndexes
-	79,  // 102: management.NetworkMapComponentsFull.RoutersMapEntry.value:type_name -> management.NetworkRouterList
-	81,  // 103: management.NetworkMapComponentsFull.ResourcePoliciesMapEntry.value:type_name -> management.PolicyIds
-	82,  // 104: management.NetworkMapComponentsFull.GroupIdToUserIdsEntry.value:type_name -> management.UserIDList
-	83,  // 105: management.NetworkMapComponentsFull.PostureFailedPeersEntry.value:type_name -> management.PeerIndexSet
-	73,  // 106: management.PolicyCompact.AuthorizedGroupsEntry.value:type_name -> management.UserNameList
-	8,   // 107: management.ManagementService.Login:input_type -> management.EncryptedMessage
-	8,   // 108: management.ManagementService.Sync:input_type -> management.EncryptedMessage
-	26,  // 109: management.ManagementService.GetServerKey:input_type -> management.Empty
-	26,  // 110: management.ManagementService.isHealthy:input_type -> management.Empty
-	8,   // 111: management.ManagementService.GetDeviceAuthorizationFlow:input_type -> management.EncryptedMessage
-	8,   // 112: management.ManagementService.GetPKCEAuthorizationFlow:input_type -> management.EncryptedMessage
-	8,   // 113: management.ManagementService.SyncMeta:input_type -> management.EncryptedMessage
-	8,   // 114: management.ManagementService.Logout:input_type -> management.EncryptedMessage
-	8,   // 115: management.ManagementService.Job:input_type -> management.EncryptedMessage
-	8,   // 116: management.ManagementService.ExtendAuthSession:input_type -> management.EncryptedMessage
-	8,   // 117: management.ManagementService.CreateExpose:input_type -> management.EncryptedMessage
-	8,   // 118: management.ManagementService.RenewExpose:input_type -> management.EncryptedMessage
-	8,   // 119: management.ManagementService.StopExpose:input_type -> management.EncryptedMessage
-	8,   // 120: management.ManagementService.Login:output_type -> management.EncryptedMessage
-	8,   // 121: management.ManagementService.Sync:output_type -> management.EncryptedMessage
-	25,  // 122: management.ManagementService.GetServerKey:output_type -> management.ServerKeyResponse
-	26,  // 123: management.ManagementService.isHealthy:output_type -> management.Empty
-	8,   // 124: management.ManagementService.GetDeviceAuthorizationFlow:output_type -> management.EncryptedMessage
-	8,   // 125: management.ManagementService.GetPKCEAuthorizationFlow:output_type -> management.EncryptedMessage
-	26,  // 126: management.ManagementService.SyncMeta:output_type -> management.Empty
-	26,  // 127: management.ManagementService.Logout:output_type -> management.Empty
-	8,   // 128: management.ManagementService.Job:output_type -> management.EncryptedMessage
-	8,   // 129: management.ManagementService.ExtendAuthSession:output_type -> management.EncryptedMessage
-	8,   // 130: management.ManagementService.CreateExpose:output_type -> management.EncryptedMessage
-	8,   // 131: management.ManagementService.RenewExpose:output_type -> management.EncryptedMessage
-	8,   // 132: management.ManagementService.StopExpose:output_type -> management.EncryptedMessage
-	120, // [120:133] is the sub-list for method output_type
-	107, // [107:120] is the sub-list for method input_type
-	107, // [107:107] is the sub-list for extension type_name
-	107, // [107:107] is the sub-list for extension extendee
-	0,   // [0:107] is the sub-list for field type_name
+	86,  // 101: management.AgentNetworkSetupResponse.providers:type_name -> management.AgentNetworkProviderInfo
+	38,  // 102: management.SSHAuth.MachineUsersEntry.value:type_name -> management.MachineUserIndexes
+	79,  // 103: management.NetworkMapComponentsFull.RoutersMapEntry.value:type_name -> management.NetworkRouterList
+	81,  // 104: management.NetworkMapComponentsFull.ResourcePoliciesMapEntry.value:type_name -> management.PolicyIds
+	82,  // 105: management.NetworkMapComponentsFull.GroupIdToUserIdsEntry.value:type_name -> management.UserIDList
+	83,  // 106: management.NetworkMapComponentsFull.PostureFailedPeersEntry.value:type_name -> management.PeerIndexSet
+	73,  // 107: management.PolicyCompact.AuthorizedGroupsEntry.value:type_name -> management.UserNameList
+	8,   // 108: management.ManagementService.Login:input_type -> management.EncryptedMessage
+	8,   // 109: management.ManagementService.Sync:input_type -> management.EncryptedMessage
+	26,  // 110: management.ManagementService.GetServerKey:input_type -> management.Empty
+	26,  // 111: management.ManagementService.isHealthy:input_type -> management.Empty
+	8,   // 112: management.ManagementService.GetDeviceAuthorizationFlow:input_type -> management.EncryptedMessage
+	8,   // 113: management.ManagementService.GetPKCEAuthorizationFlow:input_type -> management.EncryptedMessage
+	8,   // 114: management.ManagementService.SyncMeta:input_type -> management.EncryptedMessage
+	8,   // 115: management.ManagementService.Logout:input_type -> management.EncryptedMessage
+	8,   // 116: management.ManagementService.Job:input_type -> management.EncryptedMessage
+	8,   // 117: management.ManagementService.ExtendAuthSession:input_type -> management.EncryptedMessage
+	8,   // 118: management.ManagementService.CreateExpose:input_type -> management.EncryptedMessage
+	8,   // 119: management.ManagementService.RenewExpose:input_type -> management.EncryptedMessage
+	8,   // 120: management.ManagementService.StopExpose:input_type -> management.EncryptedMessage
+	8,   // 121: management.ManagementService.GetAgentNetworkSetup:input_type -> management.EncryptedMessage
+	8,   // 122: management.ManagementService.Login:output_type -> management.EncryptedMessage
+	8,   // 123: management.ManagementService.Sync:output_type -> management.EncryptedMessage
+	25,  // 124: management.ManagementService.GetServerKey:output_type -> management.ServerKeyResponse
+	26,  // 125: management.ManagementService.isHealthy:output_type -> management.Empty
+	8,   // 126: management.ManagementService.GetDeviceAuthorizationFlow:output_type -> management.EncryptedMessage
+	8,   // 127: management.ManagementService.GetPKCEAuthorizationFlow:output_type -> management.EncryptedMessage
+	26,  // 128: management.ManagementService.SyncMeta:output_type -> management.Empty
+	26,  // 129: management.ManagementService.Logout:output_type -> management.Empty
+	8,   // 130: management.ManagementService.Job:output_type -> management.EncryptedMessage
+	8,   // 131: management.ManagementService.ExtendAuthSession:output_type -> management.EncryptedMessage
+	8,   // 132: management.ManagementService.CreateExpose:output_type -> management.EncryptedMessage
+	8,   // 133: management.ManagementService.RenewExpose:output_type -> management.EncryptedMessage
+	8,   // 134: management.ManagementService.StopExpose:output_type -> management.EncryptedMessage
+	8,   // 135: management.ManagementService.GetAgentNetworkSetup:output_type -> management.EncryptedMessage
+	122, // [122:136] is the sub-list for method output_type
+	108, // [108:122] is the sub-list for method input_type
+	108, // [108:108] is the sub-list for extension type_name
+	108, // [108:108] is the sub-list for extension extendee
+	0,   // [0:108] is the sub-list for field type_name
 }
 
 func init() { file_management_proto_init() }
@@ -9007,7 +9236,43 @@ func file_management_proto_init() {
 				return nil
 			}
 		}
+		file_management_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*AgentNetworkSetupRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
 		file_management_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*AgentNetworkSetupResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_management_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*AgentNetworkProviderInfo); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_management_proto_msgTypes[80].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*PortInfo_Range); i {
 			case 0:
 				return &v.state
@@ -9040,7 +9305,7 @@ func file_management_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_management_proto_rawDesc,
 			NumEnums:      8,
-			NumMessages:   83,
+			NumMessages:   86,
 			NumExtensions: 0,
 			NumServices:   1,
 		},

shared/management/proto/management.proto

@@ -68,6 +68,13 @@ service ManagementService {
 
   // StopExpose terminates an active expose session
   rpc StopExpose(EncryptedMessage) returns (EncryptedMessage) {}
+
+  // GetAgentNetworkSetup returns the Agent Network connection info the
+  // calling peer's groups authorize: proxy endpoint plus effective
+  // providers and models. Caller-scoped by the peer's WireGuard key.
+  // EncryptedMessage of the request has a body of AgentNetworkSetupRequest.
+  // EncryptedMessage of the response has a body of AgentNetworkSetupResponse.
+  rpc GetAgentNetworkSetup(EncryptedMessage) returns (EncryptedMessage) {}
 }
 
 message EncryptedMessage {
@@ -1207,3 +1214,34 @@ message UserIDList {
 message PeerIndexSet {
   repeated uint32 peer_indexes = 1;
 }
+
+message AgentNetworkSetupRequest {}
+
+message AgentNetworkSetupResponse {
+  // configured is false when the account has no Agent Network set up or
+  // the calling peer's groups authorize none of it — the two cases are
+  // deliberately indistinguishable.
+  bool configured = 1;
+  // endpoint is the account's proxy base URL, e.g.
+  // "https://calm-otter.proxy.example.com". Reachable over the NetBird
+  // tunnel only. Empty when configured is false.
+  string endpoint = 2;
+  repeated AgentNetworkProviderInfo providers = 3;
+}
+
+message AgentNetworkProviderInfo {
+  // name is the operator-assigned provider label, e.g. "Bedrock prod".
+  string name = 1;
+  // catalog_id names the catalog entry, e.g. "anthropic_api", "bedrock_api".
+  string catalog_id = 2;
+  // api_flavor is the request-body shape the provider speaks ("anthropic",
+  // "openai"); empty when the proxy dispatches it by URL path instead.
+  string api_flavor = 3;
+  // all_models_allowed is true when no model allowlist restricts this
+  // provider for the caller; models then lists the declared/catalog models
+  // as a courtesy (possibly none for gateway-style providers).
+  bool all_models_allowed = 4;
+  // models is the effective model allowlist for the caller (or the
+  // declared/catalog models when all_models_allowed is true).
+  repeated string models = 5;
+}

shared/management/proto/management_grpc.pb.go

@@ -65,6 +65,12 @@ type ManagementServiceClient interface {
 	RenewExpose(ctx context.Context, in *EncryptedMessage, opts ...grpc.CallOption) (*EncryptedMessage, error)
 	// StopExpose terminates an active expose session
 	StopExpose(ctx context.Context, in *EncryptedMessage, opts ...grpc.CallOption) (*EncryptedMessage, error)
+	// GetAgentNetworkSetup returns the Agent Network connection info the
+	// calling peer's groups authorize: proxy endpoint plus effective
+	// providers and models. Caller-scoped by the peer's WireGuard key.
+	// EncryptedMessage of the request has a body of AgentNetworkSetupRequest.
+	// EncryptedMessage of the response has a body of AgentNetworkSetupResponse.
+	GetAgentNetworkSetup(ctx context.Context, in *EncryptedMessage, opts ...grpc.CallOption) (*EncryptedMessage, error)
 }
 
 type managementServiceClient struct {
@@ -237,6 +243,15 @@ func (c *managementServiceClient) StopExpose(ctx context.Context, in *EncryptedM
 	return out, nil
 }
 
+func (c *managementServiceClient) GetAgentNetworkSetup(ctx context.Context, in *EncryptedMessage, opts ...grpc.CallOption) (*EncryptedMessage, error) {
+	out := new(EncryptedMessage)
+	err := c.cc.Invoke(ctx, "/management.ManagementService/GetAgentNetworkSetup", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // ManagementServiceServer is the server API for ManagementService service.
 // All implementations must embed UnimplementedManagementServiceServer
 // for forward compatibility
@@ -288,6 +303,12 @@ type ManagementServiceServer interface {
 	RenewExpose(context.Context, *EncryptedMessage) (*EncryptedMessage, error)
 	// StopExpose terminates an active expose session
 	StopExpose(context.Context, *EncryptedMessage) (*EncryptedMessage, error)
+	// GetAgentNetworkSetup returns the Agent Network connection info the
+	// calling peer's groups authorize: proxy endpoint plus effective
+	// providers and models. Caller-scoped by the peer's WireGuard key.
+	// EncryptedMessage of the request has a body of AgentNetworkSetupRequest.
+	// EncryptedMessage of the response has a body of AgentNetworkSetupResponse.
+	GetAgentNetworkSetup(context.Context, *EncryptedMessage) (*EncryptedMessage, error)
 	mustEmbedUnimplementedManagementServiceServer()
 }
 
@@ -334,6 +355,9 @@ func (UnimplementedManagementServiceServer) RenewExpose(context.Context, *Encryp
 func (UnimplementedManagementServiceServer) StopExpose(context.Context, *EncryptedMessage) (*EncryptedMessage, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method StopExpose not implemented")
 }
+func (UnimplementedManagementServiceServer) GetAgentNetworkSetup(context.Context, *EncryptedMessage) (*EncryptedMessage, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetAgentNetworkSetup not implemented")
+}
 func (UnimplementedManagementServiceServer) mustEmbedUnimplementedManagementServiceServer() {}
 
 // UnsafeManagementServiceServer may be embedded to opt out of forward compatibility for this service.
@@ -592,6 +616,24 @@ func _ManagementService_StopExpose_Handler(srv interface{}, ctx context.Context,
 	return interceptor(ctx, in, info, handler)
 }
 
+func _ManagementService_GetAgentNetworkSetup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(EncryptedMessage)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ManagementServiceServer).GetAgentNetworkSetup(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/management.ManagementService/GetAgentNetworkSetup",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ManagementServiceServer).GetAgentNetworkSetup(ctx, req.(*EncryptedMessage))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 // ManagementService_ServiceDesc is the grpc.ServiceDesc for ManagementService service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -643,6 +685,10 @@ var ManagementService_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "StopExpose",
 			Handler:    _ManagementService_StopExpose_Handler,
 		},
+		{
+			MethodName: "GetAgentNetworkSetup",
+			Handler:    _ManagementService_GetAgentNetworkSetup_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{