[client] Add full sync response to debug bundle (#4287)

2025-08-18 02:50:43 +02:00 · 2025-08-05 14:55:50 +02:00
parent 92ce5afe80
commit 3d3c4c5844
10 changed files with 298 additions and 221 deletions
--- a/client/cmd/debug.go
+++ b/client/cmd/debug.go
@@ -77,11 +77,11 @@ var forCmd = &cobra.Command{

 var persistenceCmd = &cobra.Command{
 	Use:     "persistence [on|off]",
-	Short:   "Set network map memory persistence",
-	Long:    `Configure whether the latest network map should persist in memory. When enabled, the last known network map will be kept in memory.`,
+	Short:   "Set sync response memory persistence",
+	Long:    `Configure whether the latest sync response should persist in memory. When enabled, the last known sync response will be kept in memory.`,
 	Example: "  netbird debug persistence on",
 	Args:    cobra.ExactArgs(1),
-	RunE:    setNetworkMapPersistence,
+	RunE:    setSyncResponsePersistence,
 }

 func debugBundle(cmd *cobra.Command, _ []string) error {
@@ -206,11 +206,11 @@ func runForDuration(cmd *cobra.Command, args []string) error {

 	time.Sleep(1 * time.Second)

-	// Enable network map persistence before bringing the service up
-	if _, err := client.SetNetworkMapPersistence(cmd.Context(), &proto.SetNetworkMapPersistenceRequest{
+	// Enable sync response persistence before bringing the service up
+	if _, err := client.SetSyncResponsePersistence(cmd.Context(), &proto.SetSyncResponsePersistenceRequest{
 		Enabled: true,
 	}); err != nil {
-		return fmt.Errorf("failed to enable network map persistence: %v", status.Convert(err).Message())
+		return fmt.Errorf("failed to enable sync response persistence: %v", status.Convert(err).Message())
 	}

 	if _, err := client.Up(cmd.Context(), &proto.UpRequest{}); err != nil {
@@ -273,7 +273,7 @@ func runForDuration(cmd *cobra.Command, args []string) error {
 	return nil
 }

-func setNetworkMapPersistence(cmd *cobra.Command, args []string) error {
+func setSyncResponsePersistence(cmd *cobra.Command, args []string) error {
 	conn, err := getClient(cmd)
 	if err != nil {
 		return err
@@ -290,14 +290,14 @@ func setNetworkMapPersistence(cmd *cobra.Command, args []string) error {
 	}

 	client := proto.NewDaemonServiceClient(conn)
-	_, err = client.SetNetworkMapPersistence(cmd.Context(), &proto.SetNetworkMapPersistenceRequest{
+	_, err = client.SetSyncResponsePersistence(cmd.Context(), &proto.SetSyncResponsePersistenceRequest{
 		Enabled: persistence == "on",
 	})
 	if err != nil {
-		return fmt.Errorf("failed to set network map persistence: %v", status.Convert(err).Message())
+		return fmt.Errorf("failed to set sync response persistence: %v", status.Convert(err).Message())
 	}

-	cmd.Printf("Network map persistence set to: %s\n", persistence)
+	cmd.Printf("Sync response persistence set to: %s\n", persistence)
 	return nil
 }

@@ -357,13 +357,13 @@ func formatDuration(d time.Duration) string {
 }

 func generateDebugBundle(config *profilemanager.Config, recorder *peer.Status, connectClient *internal.ConnectClient, logFilePath string) {
-	var networkMap *mgmProto.NetworkMap
+	var syncResponse *mgmProto.SyncResponse
 	var err error

 	if connectClient != nil {
-		networkMap, err = connectClient.GetLatestNetworkMap()
+		syncResponse, err = connectClient.GetLatestSyncResponse()
 		if err != nil {
-			log.Warnf("Failed to get latest network map: %v", err)
+			log.Warnf("Failed to get latest sync response: %v", err)
 		}
 	}

@@ -371,7 +371,7 @@ func generateDebugBundle(config *profilemanager.Config, recorder *peer.Status, c
 		debug.GeneratorDependencies{
 			InternalConfig: config,
 			StatusRecorder: recorder,
-			NetworkMap:     networkMap,
+			SyncResponse:   syncResponse,
 			LogFile:        logFilePath,
 		},
 		debug.BundleConfig{
--- a/client/internal/connect.go
+++ b/client/internal/connect.go
@@ -43,7 +43,7 @@ type ConnectClient struct {
 	engine         *Engine
 	engineMutex    sync.Mutex

-	persistNetworkMap bool
+	persistSyncResponse bool
 }

 func NewConnectClient(
@@ -270,7 +270,7 @@ func (c *ConnectClient) run(mobileDependency MobileDependency, runningChan chan

 		c.engineMutex.Lock()
 		c.engine = NewEngine(engineCtx, cancel, signalClient, mgmClient, relayManager, engineConfig, mobileDependency, c.statusRecorder, checks)
-		c.engine.SetNetworkMapPersistence(c.persistNetworkMap)
+		c.engine.SetSyncResponsePersistence(c.persistSyncResponse)
 		c.engineMutex.Unlock()

 		if err := c.engine.Start(); err != nil {
@@ -349,23 +349,23 @@ func (c *ConnectClient) Engine() *Engine {
 	return e
 }

-// GetLatestNetworkMap returns the latest network map from the engine.
-func (c *ConnectClient) GetLatestNetworkMap() (*mgmProto.NetworkMap, error) {
+// GetLatestSyncResponse returns the latest sync response from the engine.
+func (c *ConnectClient) GetLatestSyncResponse() (*mgmProto.SyncResponse, error) {
 	engine := c.Engine()
 	if engine == nil {
 		return nil, errors.New("engine is not initialized")
 	}

-	networkMap, err := engine.GetLatestNetworkMap()
+	syncResponse, err := engine.GetLatestSyncResponse()
 	if err != nil {
-		return nil, fmt.Errorf("get latest network map: %w", err)
+		return nil, fmt.Errorf("get latest sync response: %w", err)
 	}

-	if networkMap == nil {
-		return nil, errors.New("network map is not available")
+	if syncResponse == nil {
+		return nil, errors.New("sync response is not available")
 	}

-	return networkMap, nil
+	return syncResponse, nil
 }

 // Status returns the current client status
@@ -398,18 +398,18 @@ func (c *ConnectClient) Stop() error {
 	return nil
 }

-// SetNetworkMapPersistence enables or disables network map persistence.
-// When enabled, the last received network map will be stored and can be retrieved
-// through the Engine's getLatestNetworkMap method. When disabled, any stored
-// network map will be cleared.
-func (c *ConnectClient) SetNetworkMapPersistence(enabled bool) {
+// SetSyncResponsePersistence enables or disables sync response persistence.
+// When enabled, the last received sync response will be stored and can be retrieved
+// through the Engine's GetLatestSyncResponse method. When disabled, any stored
+// sync response will be cleared.
+func (c *ConnectClient) SetSyncResponsePersistence(enabled bool) {
 	c.engineMutex.Lock()
-	c.persistNetworkMap = enabled
+	c.persistSyncResponse = enabled
 	c.engineMutex.Unlock()

 	engine := c.Engine()
 	if engine != nil {
-		engine.SetNetworkMapPersistence(enabled)
+		engine.SetSyncResponsePersistence(enabled)
 	}
 }

--- a/client/internal/debug/debug.go
+++ b/client/internal/debug/debug.go
@@ -46,7 +46,7 @@ iptables.txt: Anonymized iptables rules with packet counters, if --system-info f
 nftables.txt: Anonymized nftables rules with packet counters, if --system-info flag was provided.
 resolved_domains.txt: Anonymized resolved domain IP addresses from the status recorder.
 config.txt: Anonymized configuration information of the NetBird client.
-network_map.json: Anonymized network map containing peer configurations, routes, DNS settings, and firewall rules.
+network_map.json: Anonymized sync response containing peer configurations, routes, DNS settings, and firewall rules.
 state.json: Anonymized client state dump containing netbird states.
 mutex.prof: Mutex profiling information.
 goroutine.prof: Goroutine profiling information.
@@ -73,7 +73,7 @@ Domains
 All domain names (except for the netbird domains) are replaced with randomly generated strings ending in ".domain". Anonymized domains are consistent across all files in the bundle.
 Reoccuring domain names are replaced with the same anonymized domain.

-Network Map
+Sync Response
 The network_map.json file contains the following anonymized information:
 - Peer configurations (addresses, FQDNs, DNS settings)
 - Remote and offline peer information (allowed IPs, FQDNs)
@@ -81,7 +81,7 @@ The network_map.json file contains the following anonymized information:
 - DNS configuration (nameservers, domains, custom zones)
 - Firewall rules (peer IPs, source/destination ranges)

-SSH keys in the network map are replaced with a placeholder value. All IP addresses and domains in the network map follow the same anonymization rules as described above.
+SSH keys in the sync response are replaced with a placeholder value. All IP addresses and domains in the sync response follow the same anonymization rules as described above.

 State File
 The state.json file contains anonymized internal state information of the NetBird client, including:
@@ -201,7 +201,7 @@ type BundleGenerator struct {
 	// deps
 	internalConfig *profilemanager.Config
 	statusRecorder *peer.Status
-	networkMap     *mgmProto.NetworkMap
+	syncResponse   *mgmProto.SyncResponse
 	logFile        string

 	anonymize         bool
@@ -222,7 +222,7 @@ type BundleConfig struct {
 type GeneratorDependencies struct {
 	InternalConfig *profilemanager.Config
 	StatusRecorder *peer.Status
-	NetworkMap     *mgmProto.NetworkMap
+	SyncResponse   *mgmProto.SyncResponse
 	LogFile        string
 }

@@ -238,7 +238,7 @@ func NewBundleGenerator(deps GeneratorDependencies, cfg BundleConfig) *BundleGen

 		internalConfig: deps.InternalConfig,
 		statusRecorder: deps.StatusRecorder,
-		networkMap:     deps.NetworkMap,
+		syncResponse:   deps.SyncResponse,
 		logFile:        deps.LogFile,

 		anonymize:         cfg.Anonymize,
@@ -311,8 +311,8 @@ func (g *BundleGenerator) createArchive() error {
 		log.Errorf("failed to add profiles to debug bundle: %v", err)
 	}

-	if err := g.addNetworkMap(); err != nil {
-		return fmt.Errorf("add network map: %w", err)
+	if err := g.addSyncResponse(); err != nil {
+		return fmt.Errorf("add sync response: %w", err)
 	}

 	if err := g.addStateFile(); err != nil {
@@ -526,15 +526,15 @@ func (g *BundleGenerator) addResolvedDomains() error {
 	return nil
 }

-func (g *BundleGenerator) addNetworkMap() error {
-	if g.networkMap == nil {
-		log.Debugf("skipping empty network map in debug bundle")
+func (g *BundleGenerator) addSyncResponse() error {
+	if g.syncResponse == nil {
+		log.Debugf("skipping empty sync response in debug bundle")
 		return nil
 	}

 	if g.anonymize {
-		if err := anonymizeNetworkMap(g.networkMap, g.anonymizer); err != nil {
-			return fmt.Errorf("anonymize network map: %w", err)
+		if err := anonymizeSyncResponse(g.syncResponse, g.anonymizer); err != nil {
+			return fmt.Errorf("anonymize sync response: %w", err)
 		}
 	}

@@ -545,13 +545,13 @@ func (g *BundleGenerator) addNetworkMap() error {
 		AllowPartial:    true,
 	}

-	jsonBytes, err := options.Marshal(g.networkMap)
+	jsonBytes, err := options.Marshal(g.syncResponse)
 	if err != nil {
 		return fmt.Errorf("generate json: %w", err)
 	}

 	if err := g.addFileToZip(bytes.NewReader(jsonBytes), "network_map.json"); err != nil {
-		return fmt.Errorf("add network map to zip: %w", err)
+		return fmt.Errorf("add sync response to zip: %w", err)
 	}

 	return nil
@@ -921,6 +921,88 @@ func anonymizeNetworkMap(networkMap *mgmProto.NetworkMap, anonymizer *anonymize.
 	return nil
 }

+func anonymizeNetbirdConfig(config *mgmProto.NetbirdConfig, anonymizer *anonymize.Anonymizer) {
+	for _, stun := range config.Stuns {
+		if stun.Uri != "" {
+			stun.Uri = anonymizer.AnonymizeURI(stun.Uri)
+		}
+	}
+
+	for _, turn := range config.Turns {
+		if turn.HostConfig != nil && turn.HostConfig.Uri != "" {
+			turn.HostConfig.Uri = anonymizer.AnonymizeURI(turn.HostConfig.Uri)
+		}
+		if turn.User != "" {
+			turn.User = "turn-user-placeholder"
+		}
+		if turn.Password != "" {
+			turn.Password = "turn-password-placeholder"
+		}
+	}
+
+	if config.Signal != nil && config.Signal.Uri != "" {
+		config.Signal.Uri = anonymizer.AnonymizeURI(config.Signal.Uri)
+	}
+
+	if config.Relay != nil {
+		for i, url := range config.Relay.Urls {
+			config.Relay.Urls[i] = anonymizer.AnonymizeURI(url)
+		}
+		if config.Relay.TokenPayload != "" {
+			config.Relay.TokenPayload = "relay-token-payload-placeholder"
+		}
+		if config.Relay.TokenSignature != "" {
+			config.Relay.TokenSignature = "relay-token-signature-placeholder"
+		}
+	}
+
+	if config.Flow != nil {
+		if config.Flow.Url != "" {
+			config.Flow.Url = anonymizer.AnonymizeURI(config.Flow.Url)
+		}
+		if config.Flow.TokenPayload != "" {
+			config.Flow.TokenPayload = "flow-token-payload-placeholder"
+		}
+		if config.Flow.TokenSignature != "" {
+			config.Flow.TokenSignature = "flow-token-signature-placeholder"
+		}
+	}
+}
+
+func anonymizeSyncResponse(syncResponse *mgmProto.SyncResponse, anonymizer *anonymize.Anonymizer) error {
+	if syncResponse.NetbirdConfig != nil {
+		anonymizeNetbirdConfig(syncResponse.NetbirdConfig, anonymizer)
+	}
+
+	if syncResponse.PeerConfig != nil {
+		anonymizePeerConfig(syncResponse.PeerConfig, anonymizer)
+	}
+
+	for _, p := range syncResponse.RemotePeers {
+		anonymizeRemotePeer(p, anonymizer)
+	}
+
+	if syncResponse.NetworkMap != nil {
+		if err := anonymizeNetworkMap(syncResponse.NetworkMap, anonymizer); err != nil {
+			return err
+		}
+	}
+
+	for _, check := range syncResponse.Checks {
+		for i, file := range check.Files {
+			check.Files[i] = anonymizer.AnonymizeString(file)
+		}
+	}
+
+	return nil
+}
+
+func anonymizeSSHConfig(sshConfig *mgmProto.SSHConfig) {
+	if sshConfig != nil && len(sshConfig.SshPubKey) > 0 {
+		sshConfig.SshPubKey = []byte("ssh-placeholder-key")
+	}
+}
+
 func anonymizePeerConfig(config *mgmProto.PeerConfig, anonymizer *anonymize.Anonymizer) {
 	if config == nil {
 		return
@@ -930,9 +1012,7 @@ func anonymizePeerConfig(config *mgmProto.PeerConfig, anonymizer *anonymize.Anon
 		config.Address = anonymizer.AnonymizeIP(addr).String()
 	}

-	if config.SshConfig != nil && len(config.SshConfig.SshPubKey) > 0 {
-		config.SshConfig.SshPubKey = []byte("ssh-placeholder-key")
-	}
+	anonymizeSSHConfig(config.SshConfig)

 	config.Dns = anonymizer.AnonymizeString(config.Dns)
 	config.Fqdn = anonymizer.AnonymizeDomain(config.Fqdn)
@@ -954,9 +1034,7 @@ func anonymizeRemotePeer(peer *mgmProto.RemotePeerConfig, anonymizer *anonymize.

 	peer.Fqdn = anonymizer.AnonymizeDomain(peer.Fqdn)

-	if peer.SshConfig != nil && len(peer.SshConfig.SshPubKey) > 0 {
-		peer.SshConfig.SshPubKey = []byte("ssh-placeholder-key")
-	}
+	anonymizeSSHConfig(peer.SshConfig)
 }

 func anonymizeRoute(route *mgmProto.Route, anonymizer *anonymize.Anonymizer) {
--- a/client/internal/engine.go
+++ b/client/internal/engine.go
@@ -189,11 +189,11 @@ type Engine struct {
 	stateManager *statemanager.Manager
 	srWatcher    *guard.SRWatcher

-	// Network map persistence
-	persistNetworkMap bool
-	latestNetworkMap  *mgmProto.NetworkMap
-	connSemaphore     *semaphoregroup.SemaphoreGroup
-	flowManager       nftypes.FlowManager
+	// Sync response persistence
+	persistSyncResponse bool
+	latestSyncResponse  *mgmProto.SyncResponse
+	connSemaphore       *semaphoregroup.SemaphoreGroup
+	flowManager         nftypes.FlowManager
 }

 // Peer is an instance of the Connection Peer
@@ -697,10 +697,10 @@ func (e *Engine) handleSync(update *mgmProto.SyncResponse) error {
 		return nil
 	}

-	// Store network map if persistence is enabled
-	if e.persistNetworkMap {
-		e.latestNetworkMap = nm
-		log.Debugf("network map persisted with serial %d", nm.GetSerial())
+	// Store sync response if persistence is enabled
+	if e.persistSyncResponse {
+		e.latestSyncResponse = update
+		log.Debugf("sync response persisted with serial %d", nm.GetSerial())
 	}

 	// only apply new changes and ignore old ones
@@ -1765,44 +1765,43 @@ func (e *Engine) stopDNSServer() {
 	e.statusRecorder.UpdateDNSStates(nsGroupStates)
 }

-// SetNetworkMapPersistence enables or disables network map persistence
-func (e *Engine) SetNetworkMapPersistence(enabled bool) {
+// SetSyncResponsePersistence enables or disables sync response persistence
+func (e *Engine) SetSyncResponsePersistence(enabled bool) {
 	e.syncMsgMux.Lock()
 	defer e.syncMsgMux.Unlock()

-	if enabled == e.persistNetworkMap {
+	if enabled == e.persistSyncResponse {
 		return
 	}
-	e.persistNetworkMap = enabled
-	log.Debugf("Network map persistence is set to %t", enabled)
+	e.persistSyncResponse = enabled
+	log.Debugf("Sync response persistence is set to %t", enabled)

 	if !enabled {
-		e.latestNetworkMap = nil
+		e.latestSyncResponse = nil
 	}
 }

-// GetLatestNetworkMap returns the stored network map if persistence is enabled
-func (e *Engine) GetLatestNetworkMap() (*mgmProto.NetworkMap, error) {
+// GetLatestSyncResponse returns the stored sync response if persistence is enabled
+func (e *Engine) GetLatestSyncResponse() (*mgmProto.SyncResponse, error) {
 	e.syncMsgMux.Lock()
 	defer e.syncMsgMux.Unlock()

-	if !e.persistNetworkMap {
-		return nil, errors.New("network map persistence is disabled")
+	if !e.persistSyncResponse {
+		return nil, errors.New("sync response persistence is disabled")
 	}

-	if e.latestNetworkMap == nil {
+	if e.latestSyncResponse == nil {
 		//nolint:nilnil
 		return nil, nil
 	}

-	log.Debugf("Retrieving latest network map with size %d bytes", proto.Size(e.latestNetworkMap))
-	nm, ok := proto.Clone(e.latestNetworkMap).(*mgmProto.NetworkMap)
+	log.Debugf("Retrieving latest sync response with size %d bytes", proto.Size(e.latestSyncResponse))
+	sr, ok := proto.Clone(e.latestSyncResponse).(*mgmProto.SyncResponse)
 	if !ok {
-
-		return nil, fmt.Errorf("failed to clone network map")
+		return nil, fmt.Errorf("failed to clone sync response")
 	}

-	return nm, nil
+	return sr, nil
 }

 // GetWgAddr returns the wireguard address
--- a/client/proto/daemon.pb.go
+++ b/client/proto/daemon.pb.go
@@ -2959,27 +2959,27 @@ func (x *DeleteStateResponse) GetDeletedStates() int32 {
 	return 0
 }

-type SetNetworkMapPersistenceRequest struct {
+type SetSyncResponsePersistenceRequest struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	Enabled       bool                   `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }

-func (x *SetNetworkMapPersistenceRequest) Reset() {
-	*x = SetNetworkMapPersistenceRequest{}
+func (x *SetSyncResponsePersistenceRequest) Reset() {
+	*x = SetSyncResponsePersistenceRequest{}
 	mi := &file_daemon_proto_msgTypes[42]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }

-func (x *SetNetworkMapPersistenceRequest) String() string {
+func (x *SetSyncResponsePersistenceRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }

-func (*SetNetworkMapPersistenceRequest) ProtoMessage() {}
+func (*SetSyncResponsePersistenceRequest) ProtoMessage() {}

-func (x *SetNetworkMapPersistenceRequest) ProtoReflect() protoreflect.Message {
+func (x *SetSyncResponsePersistenceRequest) ProtoReflect() protoreflect.Message {
 	mi := &file_daemon_proto_msgTypes[42]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -2991,38 +2991,38 @@ func (x *SetNetworkMapPersistenceRequest) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }

-// Deprecated: Use SetNetworkMapPersistenceRequest.ProtoReflect.Descriptor instead.
-func (*SetNetworkMapPersistenceRequest) Descriptor() ([]byte, []int) {
+// Deprecated: Use SetSyncResponsePersistenceRequest.ProtoReflect.Descriptor instead.
+func (*SetSyncResponsePersistenceRequest) Descriptor() ([]byte, []int) {
 	return file_daemon_proto_rawDescGZIP(), []int{42}
 }

-func (x *SetNetworkMapPersistenceRequest) GetEnabled() bool {
+func (x *SetSyncResponsePersistenceRequest) GetEnabled() bool {
 	if x != nil {
 		return x.Enabled
 	}
 	return false
 }

-type SetNetworkMapPersistenceResponse struct {
+type SetSyncResponsePersistenceResponse struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }

-func (x *SetNetworkMapPersistenceResponse) Reset() {
-	*x = SetNetworkMapPersistenceResponse{}
+func (x *SetSyncResponsePersistenceResponse) Reset() {
+	*x = SetSyncResponsePersistenceResponse{}
 	mi := &file_daemon_proto_msgTypes[43]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }

-func (x *SetNetworkMapPersistenceResponse) String() string {
+func (x *SetSyncResponsePersistenceResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }

-func (*SetNetworkMapPersistenceResponse) ProtoMessage() {}
+func (*SetSyncResponsePersistenceResponse) ProtoMessage() {}

-func (x *SetNetworkMapPersistenceResponse) ProtoReflect() protoreflect.Message {
+func (x *SetSyncResponsePersistenceResponse) ProtoReflect() protoreflect.Message {
 	mi := &file_daemon_proto_msgTypes[43]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -3034,8 +3034,8 @@ func (x *SetNetworkMapPersistenceResponse) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }

-// Deprecated: Use SetNetworkMapPersistenceResponse.ProtoReflect.Descriptor instead.
-func (*SetNetworkMapPersistenceResponse) Descriptor() ([]byte, []int) {
+// Deprecated: Use SetSyncResponsePersistenceResponse.ProtoReflect.Descriptor instead.
+func (*SetSyncResponsePersistenceResponse) Descriptor() ([]byte, []int) {
 	return file_daemon_proto_rawDescGZIP(), []int{43}
 }

@@ -4727,10 +4727,10 @@ const file_daemon_proto_rawDesc = "" +
 	"state_name\x18\x01 \x01(\tR\tstateName\x12\x10\n" +
 	"\x03all\x18\x02 \x01(\bR\x03all\"<\n" +
 	"\x13DeleteStateResponse\x12%\n" +
-	"\x0edeleted_states\x18\x01 \x01(\x05R\rdeletedStates\";\n" +
-	"\x1fSetNetworkMapPersistenceRequest\x12\x18\n" +
-	"\aenabled\x18\x01 \x01(\bR\aenabled\"\"\n" +
-	" SetNetworkMapPersistenceResponse\"v\n" +
+	"\x0edeleted_states\x18\x01 \x01(\x05R\rdeletedStates\"=\n" +
+	"!SetSyncResponsePersistenceRequest\x12\x18\n" +
+	"\aenabled\x18\x01 \x01(\bR\aenabled\"$\n" +
+	"\"SetSyncResponsePersistenceResponse\"v\n" +
 	"\bTCPFlags\x12\x10\n" +
 	"\x03syn\x18\x01 \x01(\bR\x03syn\x12\x10\n" +
 	"\x03ack\x18\x02 \x01(\bR\x03ack\x12\x10\n" +
@@ -4881,7 +4881,7 @@ const file_daemon_proto_rawDesc = "" +
 	"\x04WARN\x10\x04\x12\b\n" +
 	"\x04INFO\x10\x05\x12\t\n" +
 	"\x05DEBUG\x10\x06\x12\t\n" +
-	"\x05TRACE\x10\a2\xbf\x0f\n" +
+	"\x05TRACE\x10\a2\xc5\x0f\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" +
@@ -4900,8 +4900,8 @@ const file_daemon_proto_rawDesc = "" +
 	"ListStates\x12\x19.daemon.ListStatesRequest\x1a\x1a.daemon.ListStatesResponse\"\x00\x12E\n" +
 	"\n" +
 	"CleanState\x12\x19.daemon.CleanStateRequest\x1a\x1a.daemon.CleanStateResponse\"\x00\x12H\n" +
-	"\vDeleteState\x12\x1a.daemon.DeleteStateRequest\x1a\x1b.daemon.DeleteStateResponse\"\x00\x12o\n" +
-	"\x18SetNetworkMapPersistence\x12'.daemon.SetNetworkMapPersistenceRequest\x1a(.daemon.SetNetworkMapPersistenceResponse\"\x00\x12H\n" +
+	"\vDeleteState\x12\x1a.daemon.DeleteStateRequest\x1a\x1b.daemon.DeleteStateResponse\"\x00\x12u\n" +
+	"\x1aSetSyncResponsePersistence\x12).daemon.SetSyncResponsePersistenceRequest\x1a*.daemon.SetSyncResponsePersistenceResponse\"\x00\x12H\n" +
 	"\vTracePacket\x12\x1a.daemon.TracePacketRequest\x1a\x1b.daemon.TracePacketResponse\"\x00\x12D\n" +
 	"\x0fSubscribeEvents\x12\x18.daemon.SubscribeRequest\x1a\x13.daemon.SystemEvent\"\x000\x01\x12B\n" +
 	"\tGetEvents\x12\x18.daemon.GetEventsRequest\x1a\x19.daemon.GetEventsResponse\"\x00\x12N\n" +
@@ -4929,81 +4929,81 @@ func file_daemon_proto_rawDescGZIP() []byte {
 var file_daemon_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
 var file_daemon_proto_msgTypes = make([]protoimpl.MessageInfo, 70)
 var file_daemon_proto_goTypes = []any{
-	(LogLevel)(0),                            // 0: daemon.LogLevel
-	(SystemEvent_Severity)(0),                // 1: daemon.SystemEvent.Severity
-	(SystemEvent_Category)(0),                // 2: daemon.SystemEvent.Category
-	(*EmptyRequest)(nil),                     // 3: daemon.EmptyRequest
-	(*LoginRequest)(nil),                     // 4: daemon.LoginRequest
-	(*LoginResponse)(nil),                    // 5: daemon.LoginResponse
-	(*WaitSSOLoginRequest)(nil),              // 6: daemon.WaitSSOLoginRequest
-	(*WaitSSOLoginResponse)(nil),             // 7: daemon.WaitSSOLoginResponse
-	(*UpRequest)(nil),                        // 8: daemon.UpRequest
-	(*UpResponse)(nil),                       // 9: daemon.UpResponse
-	(*StatusRequest)(nil),                    // 10: daemon.StatusRequest
-	(*StatusResponse)(nil),                   // 11: daemon.StatusResponse
-	(*DownRequest)(nil),                      // 12: daemon.DownRequest
-	(*DownResponse)(nil),                     // 13: daemon.DownResponse
-	(*GetConfigRequest)(nil),                 // 14: daemon.GetConfigRequest
-	(*GetConfigResponse)(nil),                // 15: daemon.GetConfigResponse
-	(*PeerState)(nil),                        // 16: daemon.PeerState
-	(*LocalPeerState)(nil),                   // 17: daemon.LocalPeerState
-	(*SignalState)(nil),                      // 18: daemon.SignalState
-	(*ManagementState)(nil),                  // 19: daemon.ManagementState
-	(*RelayState)(nil),                       // 20: daemon.RelayState
-	(*NSGroupState)(nil),                     // 21: daemon.NSGroupState
-	(*FullStatus)(nil),                       // 22: daemon.FullStatus
-	(*ListNetworksRequest)(nil),              // 23: daemon.ListNetworksRequest
-	(*ListNetworksResponse)(nil),             // 24: daemon.ListNetworksResponse
-	(*SelectNetworksRequest)(nil),            // 25: daemon.SelectNetworksRequest
-	(*SelectNetworksResponse)(nil),           // 26: daemon.SelectNetworksResponse
-	(*IPList)(nil),                           // 27: daemon.IPList
-	(*Network)(nil),                          // 28: daemon.Network
-	(*PortInfo)(nil),                         // 29: daemon.PortInfo
-	(*ForwardingRule)(nil),                   // 30: daemon.ForwardingRule
-	(*ForwardingRulesResponse)(nil),          // 31: daemon.ForwardingRulesResponse
-	(*DebugBundleRequest)(nil),               // 32: daemon.DebugBundleRequest
-	(*DebugBundleResponse)(nil),              // 33: daemon.DebugBundleResponse
-	(*GetLogLevelRequest)(nil),               // 34: daemon.GetLogLevelRequest
-	(*GetLogLevelResponse)(nil),              // 35: daemon.GetLogLevelResponse
-	(*SetLogLevelRequest)(nil),               // 36: daemon.SetLogLevelRequest
-	(*SetLogLevelResponse)(nil),              // 37: daemon.SetLogLevelResponse
-	(*State)(nil),                            // 38: daemon.State
-	(*ListStatesRequest)(nil),                // 39: daemon.ListStatesRequest
-	(*ListStatesResponse)(nil),               // 40: daemon.ListStatesResponse
-	(*CleanStateRequest)(nil),                // 41: daemon.CleanStateRequest
-	(*CleanStateResponse)(nil),               // 42: daemon.CleanStateResponse
-	(*DeleteStateRequest)(nil),               // 43: daemon.DeleteStateRequest
-	(*DeleteStateResponse)(nil),              // 44: daemon.DeleteStateResponse
-	(*SetNetworkMapPersistenceRequest)(nil),  // 45: daemon.SetNetworkMapPersistenceRequest
-	(*SetNetworkMapPersistenceResponse)(nil), // 46: daemon.SetNetworkMapPersistenceResponse
-	(*TCPFlags)(nil),                         // 47: daemon.TCPFlags
-	(*TracePacketRequest)(nil),               // 48: daemon.TracePacketRequest
-	(*TraceStage)(nil),                       // 49: daemon.TraceStage
-	(*TracePacketResponse)(nil),              // 50: daemon.TracePacketResponse
-	(*SubscribeRequest)(nil),                 // 51: daemon.SubscribeRequest
-	(*SystemEvent)(nil),                      // 52: daemon.SystemEvent
-	(*GetEventsRequest)(nil),                 // 53: daemon.GetEventsRequest
-	(*GetEventsResponse)(nil),                // 54: daemon.GetEventsResponse
-	(*SwitchProfileRequest)(nil),             // 55: daemon.SwitchProfileRequest
-	(*SwitchProfileResponse)(nil),            // 56: daemon.SwitchProfileResponse
-	(*SetConfigRequest)(nil),                 // 57: daemon.SetConfigRequest
-	(*SetConfigResponse)(nil),                // 58: daemon.SetConfigResponse
-	(*AddProfileRequest)(nil),                // 59: daemon.AddProfileRequest
-	(*AddProfileResponse)(nil),               // 60: daemon.AddProfileResponse
-	(*RemoveProfileRequest)(nil),             // 61: daemon.RemoveProfileRequest
-	(*RemoveProfileResponse)(nil),            // 62: daemon.RemoveProfileResponse
-	(*ListProfilesRequest)(nil),              // 63: daemon.ListProfilesRequest
-	(*ListProfilesResponse)(nil),             // 64: daemon.ListProfilesResponse
-	(*Profile)(nil),                          // 65: daemon.Profile
-	(*GetActiveProfileRequest)(nil),          // 66: daemon.GetActiveProfileRequest
-	(*GetActiveProfileResponse)(nil),         // 67: daemon.GetActiveProfileResponse
-	(*LogoutRequest)(nil),                    // 68: daemon.LogoutRequest
-	(*LogoutResponse)(nil),                   // 69: daemon.LogoutResponse
-	nil,                                      // 70: daemon.Network.ResolvedIPsEntry
-	(*PortInfo_Range)(nil),                   // 71: daemon.PortInfo.Range
-	nil,                                      // 72: daemon.SystemEvent.MetadataEntry
-	(*durationpb.Duration)(nil),              // 73: google.protobuf.Duration
-	(*timestamppb.Timestamp)(nil),            // 74: google.protobuf.Timestamp
+	(LogLevel)(0),                              // 0: daemon.LogLevel
+	(SystemEvent_Severity)(0),                  // 1: daemon.SystemEvent.Severity
+	(SystemEvent_Category)(0),                  // 2: daemon.SystemEvent.Category
+	(*EmptyRequest)(nil),                       // 3: daemon.EmptyRequest
+	(*LoginRequest)(nil),                       // 4: daemon.LoginRequest
+	(*LoginResponse)(nil),                      // 5: daemon.LoginResponse
+	(*WaitSSOLoginRequest)(nil),                // 6: daemon.WaitSSOLoginRequest
+	(*WaitSSOLoginResponse)(nil),               // 7: daemon.WaitSSOLoginResponse
+	(*UpRequest)(nil),                          // 8: daemon.UpRequest
+	(*UpResponse)(nil),                         // 9: daemon.UpResponse
+	(*StatusRequest)(nil),                      // 10: daemon.StatusRequest
+	(*StatusResponse)(nil),                     // 11: daemon.StatusResponse
+	(*DownRequest)(nil),                        // 12: daemon.DownRequest
+	(*DownResponse)(nil),                       // 13: daemon.DownResponse
+	(*GetConfigRequest)(nil),                   // 14: daemon.GetConfigRequest
+	(*GetConfigResponse)(nil),                  // 15: daemon.GetConfigResponse
+	(*PeerState)(nil),                          // 16: daemon.PeerState
+	(*LocalPeerState)(nil),                     // 17: daemon.LocalPeerState
+	(*SignalState)(nil),                        // 18: daemon.SignalState
+	(*ManagementState)(nil),                    // 19: daemon.ManagementState
+	(*RelayState)(nil),                         // 20: daemon.RelayState
+	(*NSGroupState)(nil),                       // 21: daemon.NSGroupState
+	(*FullStatus)(nil),                         // 22: daemon.FullStatus
+	(*ListNetworksRequest)(nil),                // 23: daemon.ListNetworksRequest
+	(*ListNetworksResponse)(nil),               // 24: daemon.ListNetworksResponse
+	(*SelectNetworksRequest)(nil),              // 25: daemon.SelectNetworksRequest
+	(*SelectNetworksResponse)(nil),             // 26: daemon.SelectNetworksResponse
+	(*IPList)(nil),                             // 27: daemon.IPList
+	(*Network)(nil),                            // 28: daemon.Network
+	(*PortInfo)(nil),                           // 29: daemon.PortInfo
+	(*ForwardingRule)(nil),                     // 30: daemon.ForwardingRule
+	(*ForwardingRulesResponse)(nil),            // 31: daemon.ForwardingRulesResponse
+	(*DebugBundleRequest)(nil),                 // 32: daemon.DebugBundleRequest
+	(*DebugBundleResponse)(nil),                // 33: daemon.DebugBundleResponse
+	(*GetLogLevelRequest)(nil),                 // 34: daemon.GetLogLevelRequest
+	(*GetLogLevelResponse)(nil),                // 35: daemon.GetLogLevelResponse
+	(*SetLogLevelRequest)(nil),                 // 36: daemon.SetLogLevelRequest
+	(*SetLogLevelResponse)(nil),                // 37: daemon.SetLogLevelResponse
+	(*State)(nil),                              // 38: daemon.State
+	(*ListStatesRequest)(nil),                  // 39: daemon.ListStatesRequest
+	(*ListStatesResponse)(nil),                 // 40: daemon.ListStatesResponse
+	(*CleanStateRequest)(nil),                  // 41: daemon.CleanStateRequest
+	(*CleanStateResponse)(nil),                 // 42: daemon.CleanStateResponse
+	(*DeleteStateRequest)(nil),                 // 43: daemon.DeleteStateRequest
+	(*DeleteStateResponse)(nil),                // 44: daemon.DeleteStateResponse
+	(*SetSyncResponsePersistenceRequest)(nil),  // 45: daemon.SetSyncResponsePersistenceRequest
+	(*SetSyncResponsePersistenceResponse)(nil), // 46: daemon.SetSyncResponsePersistenceResponse
+	(*TCPFlags)(nil),                           // 47: daemon.TCPFlags
+	(*TracePacketRequest)(nil),                 // 48: daemon.TracePacketRequest
+	(*TraceStage)(nil),                         // 49: daemon.TraceStage
+	(*TracePacketResponse)(nil),                // 50: daemon.TracePacketResponse
+	(*SubscribeRequest)(nil),                   // 51: daemon.SubscribeRequest
+	(*SystemEvent)(nil),                        // 52: daemon.SystemEvent
+	(*GetEventsRequest)(nil),                   // 53: daemon.GetEventsRequest
+	(*GetEventsResponse)(nil),                  // 54: daemon.GetEventsResponse
+	(*SwitchProfileRequest)(nil),               // 55: daemon.SwitchProfileRequest
+	(*SwitchProfileResponse)(nil),              // 56: daemon.SwitchProfileResponse
+	(*SetConfigRequest)(nil),                   // 57: daemon.SetConfigRequest
+	(*SetConfigResponse)(nil),                  // 58: daemon.SetConfigResponse
+	(*AddProfileRequest)(nil),                  // 59: daemon.AddProfileRequest
+	(*AddProfileResponse)(nil),                 // 60: daemon.AddProfileResponse
+	(*RemoveProfileRequest)(nil),               // 61: daemon.RemoveProfileRequest
+	(*RemoveProfileResponse)(nil),              // 62: daemon.RemoveProfileResponse
+	(*ListProfilesRequest)(nil),                // 63: daemon.ListProfilesRequest
+	(*ListProfilesResponse)(nil),               // 64: daemon.ListProfilesResponse
+	(*Profile)(nil),                            // 65: daemon.Profile
+	(*GetActiveProfileRequest)(nil),            // 66: daemon.GetActiveProfileRequest
+	(*GetActiveProfileResponse)(nil),           // 67: daemon.GetActiveProfileResponse
+	(*LogoutRequest)(nil),                      // 68: daemon.LogoutRequest
+	(*LogoutResponse)(nil),                     // 69: daemon.LogoutResponse
+	nil,                                        // 70: daemon.Network.ResolvedIPsEntry
+	(*PortInfo_Range)(nil),                     // 71: daemon.PortInfo.Range
+	nil,                                        // 72: daemon.SystemEvent.MetadataEntry
+	(*durationpb.Duration)(nil),                // 73: google.protobuf.Duration
+	(*timestamppb.Timestamp)(nil),              // 74: google.protobuf.Timestamp
 }
 var file_daemon_proto_depIdxs = []int32{
 	73, // 0: daemon.LoginRequest.dnsRouteInterval:type_name -> google.protobuf.Duration
@@ -5053,7 +5053,7 @@ var file_daemon_proto_depIdxs = []int32{
 	39, // 44: daemon.DaemonService.ListStates:input_type -> daemon.ListStatesRequest
 	41, // 45: daemon.DaemonService.CleanState:input_type -> daemon.CleanStateRequest
 	43, // 46: daemon.DaemonService.DeleteState:input_type -> daemon.DeleteStateRequest
-	45, // 47: daemon.DaemonService.SetNetworkMapPersistence:input_type -> daemon.SetNetworkMapPersistenceRequest
+	45, // 47: daemon.DaemonService.SetSyncResponsePersistence:input_type -> daemon.SetSyncResponsePersistenceRequest
 	48, // 48: daemon.DaemonService.TracePacket:input_type -> daemon.TracePacketRequest
 	51, // 49: daemon.DaemonService.SubscribeEvents:input_type -> daemon.SubscribeRequest
 	53, // 50: daemon.DaemonService.GetEvents:input_type -> daemon.GetEventsRequest
@@ -5080,7 +5080,7 @@ var file_daemon_proto_depIdxs = []int32{
 	40, // 71: daemon.DaemonService.ListStates:output_type -> daemon.ListStatesResponse
 	42, // 72: daemon.DaemonService.CleanState:output_type -> daemon.CleanStateResponse
 	44, // 73: daemon.DaemonService.DeleteState:output_type -> daemon.DeleteStateResponse
-	46, // 74: daemon.DaemonService.SetNetworkMapPersistence:output_type -> daemon.SetNetworkMapPersistenceResponse
+	46, // 74: daemon.DaemonService.SetSyncResponsePersistence:output_type -> daemon.SetSyncResponsePersistenceResponse
 	50, // 75: daemon.DaemonService.TracePacket:output_type -> daemon.TracePacketResponse
 	52, // 76: daemon.DaemonService.SubscribeEvents:output_type -> daemon.SystemEvent
 	54, // 77: daemon.DaemonService.GetEvents:output_type -> daemon.GetEventsResponse
--- a/client/proto/daemon.proto
+++ b/client/proto/daemon.proto
@@ -59,8 +59,8 @@ service DaemonService {
  // Delete specific state or all states
  rpc DeleteState(DeleteStateRequest) returns (DeleteStateResponse) {}

-  // SetNetworkMapPersistence enables or disables network map persistence
-  rpc SetNetworkMapPersistence(SetNetworkMapPersistenceRequest) returns (SetNetworkMapPersistenceResponse) {}
+  // SetSyncResponsePersistence enables or disables sync response persistence
+  rpc SetSyncResponsePersistence(SetSyncResponsePersistenceRequest) returns (SetSyncResponsePersistenceResponse) {}

  rpc TracePacket(TracePacketRequest) returns (TracePacketResponse) {}

@@ -452,11 +452,11 @@ message DeleteStateResponse {
 }


-message SetNetworkMapPersistenceRequest {
+message SetSyncResponsePersistenceRequest {
  bool enabled = 1;
 }

-message SetNetworkMapPersistenceResponse {}
+message SetSyncResponsePersistenceResponse {}

 message TCPFlags {
  bool syn = 1;
--- a/client/proto/daemon_grpc.pb.go
+++ b/client/proto/daemon_grpc.pb.go
@@ -50,8 +50,8 @@ type DaemonServiceClient interface {
 	CleanState(ctx context.Context, in *CleanStateRequest, opts ...grpc.CallOption) (*CleanStateResponse, error)
 	// Delete specific state or all states
 	DeleteState(ctx context.Context, in *DeleteStateRequest, opts ...grpc.CallOption) (*DeleteStateResponse, error)
-	// SetNetworkMapPersistence enables or disables network map persistence
-	SetNetworkMapPersistence(ctx context.Context, in *SetNetworkMapPersistenceRequest, opts ...grpc.CallOption) (*SetNetworkMapPersistenceResponse, error)
+	// SetSyncResponsePersistence enables or disables sync response persistence
+	SetSyncResponsePersistence(ctx context.Context, in *SetSyncResponsePersistenceRequest, opts ...grpc.CallOption) (*SetSyncResponsePersistenceResponse, error)
 	TracePacket(ctx context.Context, in *TracePacketRequest, opts ...grpc.CallOption) (*TracePacketResponse, error)
 	SubscribeEvents(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (DaemonService_SubscribeEventsClient, error)
 	GetEvents(ctx context.Context, in *GetEventsRequest, opts ...grpc.CallOption) (*GetEventsResponse, error)
@@ -217,9 +217,9 @@ func (c *daemonServiceClient) DeleteState(ctx context.Context, in *DeleteStateRe
 	return out, nil
 }

-func (c *daemonServiceClient) SetNetworkMapPersistence(ctx context.Context, in *SetNetworkMapPersistenceRequest, opts ...grpc.CallOption) (*SetNetworkMapPersistenceResponse, error) {
-	out := new(SetNetworkMapPersistenceResponse)
-	err := c.cc.Invoke(ctx, "/daemon.DaemonService/SetNetworkMapPersistence", in, out, opts...)
+func (c *daemonServiceClient) SetSyncResponsePersistence(ctx context.Context, in *SetSyncResponsePersistenceRequest, opts ...grpc.CallOption) (*SetSyncResponsePersistenceResponse, error) {
+	out := new(SetSyncResponsePersistenceResponse)
+	err := c.cc.Invoke(ctx, "/daemon.DaemonService/SetSyncResponsePersistence", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -375,8 +375,8 @@ type DaemonServiceServer interface {
 	CleanState(context.Context, *CleanStateRequest) (*CleanStateResponse, error)
 	// Delete specific state or all states
 	DeleteState(context.Context, *DeleteStateRequest) (*DeleteStateResponse, error)
-	// SetNetworkMapPersistence enables or disables network map persistence
-	SetNetworkMapPersistence(context.Context, *SetNetworkMapPersistenceRequest) (*SetNetworkMapPersistenceResponse, error)
+	// SetSyncResponsePersistence enables or disables sync response persistence
+	SetSyncResponsePersistence(context.Context, *SetSyncResponsePersistenceRequest) (*SetSyncResponsePersistenceResponse, error)
 	TracePacket(context.Context, *TracePacketRequest) (*TracePacketResponse, error)
 	SubscribeEvents(*SubscribeRequest, DaemonService_SubscribeEventsServer) error
 	GetEvents(context.Context, *GetEventsRequest) (*GetEventsResponse, error)
@@ -443,8 +443,8 @@ func (UnimplementedDaemonServiceServer) CleanState(context.Context, *CleanStateR
 func (UnimplementedDaemonServiceServer) DeleteState(context.Context, *DeleteStateRequest) (*DeleteStateResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method DeleteState not implemented")
 }
-func (UnimplementedDaemonServiceServer) SetNetworkMapPersistence(context.Context, *SetNetworkMapPersistenceRequest) (*SetNetworkMapPersistenceResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method SetNetworkMapPersistence not implemented")
+func (UnimplementedDaemonServiceServer) SetSyncResponsePersistence(context.Context, *SetSyncResponsePersistenceRequest) (*SetSyncResponsePersistenceResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method SetSyncResponsePersistence not implemented")
 }
 func (UnimplementedDaemonServiceServer) TracePacket(context.Context, *TracePacketRequest) (*TracePacketResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method TracePacket not implemented")
@@ -777,20 +777,20 @@ func _DaemonService_DeleteState_Handler(srv interface{}, ctx context.Context, de
 	return interceptor(ctx, in, info, handler)
 }

-func _DaemonService_SetNetworkMapPersistence_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(SetNetworkMapPersistenceRequest)
+func _DaemonService_SetSyncResponsePersistence_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(SetSyncResponsePersistenceRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(DaemonServiceServer).SetNetworkMapPersistence(ctx, in)
+		return srv.(DaemonServiceServer).SetSyncResponsePersistence(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/daemon.DaemonService/SetNetworkMapPersistence",
+		FullMethod: "/daemon.DaemonService/SetSyncResponsePersistence",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(DaemonServiceServer).SetNetworkMapPersistence(ctx, req.(*SetNetworkMapPersistenceRequest))
+		return srv.(DaemonServiceServer).SetSyncResponsePersistence(ctx, req.(*SetSyncResponsePersistenceRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -1050,8 +1050,8 @@ var DaemonService_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _DaemonService_DeleteState_Handler,
 		},
 		{
-			MethodName: "SetNetworkMapPersistence",
-			Handler:    _DaemonService_SetNetworkMapPersistence_Handler,
+			MethodName: "SetSyncResponsePersistence",
+			Handler:    _DaemonService_SetSyncResponsePersistence_Handler,
 		},
 		{
 			MethodName: "TracePacket",
--- a/client/server/debug.go
+++ b/client/server/debug.go
@@ -27,15 +27,16 @@ func (s *Server) DebugBundle(_ context.Context, req *proto.DebugBundleRequest) (
 	s.mutex.Lock()
 	defer s.mutex.Unlock()

-	networkMap, err := s.getLatestNetworkMap()
+	syncResponse, err := s.getLatestSyncResponse()
 	if err != nil {
-		log.Warnf("failed to get latest network map: %v", err)
+		log.Warnf("failed to get latest sync response: %v", err)
 	}
+
 	bundleGenerator := debug.NewBundleGenerator(
 		debug.GeneratorDependencies{
 			InternalConfig: s.config,
 			StatusRecorder: s.statusRecorder,
-			NetworkMap:     networkMap,
+			SyncResponse:   syncResponse,
 			LogFile:        s.logFile,
 		},
 		debug.BundleConfig{
@@ -192,26 +193,25 @@ func (s *Server) SetLogLevel(_ context.Context, req *proto.SetLogLevelRequest) (
 	return &proto.SetLogLevelResponse{}, nil
 }

-// SetNetworkMapPersistence sets the network map persistence for the server.
-func (s *Server) SetNetworkMapPersistence(_ context.Context, req *proto.SetNetworkMapPersistenceRequest) (*proto.SetNetworkMapPersistenceResponse, error) {
+// SetSyncResponsePersistence sets the sync response persistence for the server.
+func (s *Server) SetSyncResponsePersistence(_ context.Context, req *proto.SetSyncResponsePersistenceRequest) (*proto.SetSyncResponsePersistenceResponse, error) {
 	s.mutex.Lock()
 	defer s.mutex.Unlock()

 	enabled := req.GetEnabled()
-	s.persistNetworkMap = enabled
+	s.persistSyncResponse = enabled
 	if s.connectClient != nil {
-		s.connectClient.SetNetworkMapPersistence(enabled)
+		s.connectClient.SetSyncResponsePersistence(enabled)
 	}

-	return &proto.SetNetworkMapPersistenceResponse{}, nil
+	return &proto.SetSyncResponsePersistenceResponse{}, nil
 }

-// getLatestNetworkMap returns the latest network map from the engine if network map persistence is enabled
-func (s *Server) getLatestNetworkMap() (*mgmProto.NetworkMap, error) {
+func (s *Server) getLatestSyncResponse() (*mgmProto.SyncResponse, error) {
 	cClient := s.connectClient
 	if cClient == nil {
 		return nil, errors.New("connect client is not initialized")
 	}

-	return cClient.GetLatestNetworkMap()
+	return cClient.GetLatestSyncResponse()
 }
--- a/client/server/server.go
+++ b/client/server/server.go
@@ -70,9 +70,9 @@ type Server struct {
 	statusRecorder *peer.Status
 	sessionWatcher *internal.SessionWatcher

-	lastProbe         time.Time
-	persistNetworkMap bool
-	isSessionActive   atomic.Bool
+	lastProbe           time.Time
+	persistSyncResponse bool
+	isSessionActive     atomic.Bool

 	profileManager   *profilemanager.ServiceManager
 	profilesDisabled bool
@@ -88,12 +88,12 @@ type oauthAuthFlow struct {
 // New server instance constructor.
 func New(ctx context.Context, logFile string, configFile string, profilesDisabled bool) *Server {
 	return &Server{
-		rootCtx:           ctx,
-		logFile:           logFile,
-		persistNetworkMap: true,
-		statusRecorder:    peer.NewRecorder(""),
-		profileManager:    profilemanager.NewServiceManager(configFile),
-		profilesDisabled:  profilesDisabled,
+		rootCtx:             ctx,
+		logFile:             logFile,
+		persistSyncResponse: true,
+		statusRecorder:      peer.NewRecorder(""),
+		profileManager:      profilemanager.NewServiceManager(configFile),
+		profilesDisabled:    profilesDisabled,
 	}
 }

@@ -233,7 +233,7 @@ func (s *Server) connectWithRetryRuns(ctx context.Context, config *profilemanage
 	runOperation := func() error {
 		log.Tracef("running client connection")
 		s.connectClient = internal.NewConnectClient(ctx, config, statusRecorder)
-		s.connectClient.SetNetworkMapPersistence(s.persistNetworkMap)
+		s.connectClient.SetSyncResponsePersistence(s.persistSyncResponse)

 		err := s.connectClient.Run(runningChan)
 		if err != nil {
--- a/client/ui/debug.go
+++ b/client/ui/debug.go
@@ -395,12 +395,12 @@ func (s *serviceClient) configureServiceForDebug(
 	time.Sleep(time.Second)

 	if enablePersistence {
-		if _, err := conn.SetNetworkMapPersistence(s.ctx, &proto.SetNetworkMapPersistenceRequest{
+		if _, err := conn.SetSyncResponsePersistence(s.ctx, &proto.SetSyncResponsePersistenceRequest{
 			Enabled: true,
 		}); err != nil {
-			return fmt.Errorf("enable network map persistence: %v", err)
+			return fmt.Errorf("enable sync response persistence: %v", err)
 		}
-		log.Info("Network map persistence enabled for debug")
+		log.Info("Sync response persistence enabled for debug")
 	}

 	if _, err := conn.Up(s.ctx, &proto.UpRequest{}); err != nil {