feat: Don't show virtual default if desktop default is present

#13
Branch: Profiles-13

Signed-off-by: Gabe Goodhart <ghart@us.ibm.com>

Author: gabe-l-hart

cforge/profile_utils.py

@@ -100,6 +100,15 @@ def validate_active_profile_id(cls, active_profile_id: Optional[str], info: Vali
         return active_profile_id
 
 
+def get_default_api_url() -> str:
+    """Get the default API URL if not set via a profile
+
+    Returns:
+        URL based on configured settings
+    """
+    return f"http://{get_settings().host}:{get_settings().port}"
+
+
 def get_profile_store_path() -> Path:
     """Get the path to the profile store file.
 
@@ -143,27 +152,31 @@ def get_all_profiles() -> List[AuthProfile]:
     """Get all profiles, including the virtual default profile.
 
     Returns:
-        List of all profiles, including virtual default if no store exists
+        List of all profiles, including virtual default if no Desktop default exists
     """
     profiles = []
     if store := load_profile_store():
         profiles = list(store.profiles.values())
 
-    # Always include the virtual default profile
-    settings = get_settings()
-    default_profile = AuthProfile(
-        id=DEFAULT_PROFILE_ID,
-        name="Local Default",
-        email="admin@localhost",
-        api_url=f"http://{settings.host}:{settings.port}",
-        is_active=not bool(store and store.active_profile_id),
-        created_at=datetime.now(),
-        metadata=ProfileMetadata(
-            description="Default local development profile",
-            environment="local",
-        ),
-    )
-    profiles.append(default_profile)
+    # Check if Desktop app has created a default profile
+    expected_default_url = get_default_api_url()
+    has_desktop_default = any(p.api_url == expected_default_url and p.metadata and p.metadata.is_internal for p in profiles)
+
+    # Only include virtual default if Desktop hasn't created one
+    if not has_desktop_default:
+        default_profile = AuthProfile(
+            id=DEFAULT_PROFILE_ID,
+            name="Local Default",
+            email="admin@localhost",
+            api_url=expected_default_url,
+            is_active=not bool(store and store.active_profile_id),
+            created_at=datetime.now(),
+            metadata=ProfileMetadata(
+                description="Default local development profile",
+                environment="local",
+            ),
+        )
+        profiles.append(default_profile)
 
     return profiles
 
@@ -179,13 +192,12 @@ def get_profile(profile_id: str) -> Optional[AuthProfile]:
     """
     # Check for virtual default profile
     if profile_id == DEFAULT_PROFILE_ID:
-        settings = get_settings()
         store = load_profile_store()
         return AuthProfile(
             id=DEFAULT_PROFILE_ID,
             name="Local Default",
             email="admin@localhost",
-            api_url=f"http://{settings.host}:{settings.port}",
+            api_url=get_default_api_url(),
             is_active=not bool(store and store.active_profile_id),
             created_at=datetime.now(),
             metadata=ProfileMetadata(
@@ -203,17 +215,26 @@ def get_active_profile() -> Optional[AuthProfile]:
 
     Returns:
         AuthProfile if an active profile is set, or the virtual default profile
+        if no Desktop default exists
     """
     if (store := load_profile_store()) and store.active_profile_id:
         return store.profiles.get(store.active_profile_id)
 
-    # Return virtual default profile if no active profile
-    settings = get_settings()
+    # Check if Desktop app has created a default profile
+    expected_default_url = get_default_api_url()
+
+    if store:
+        for profile in store.profiles.values():
+            if profile.api_url == expected_default_url and profile.metadata and profile.metadata.is_internal:
+                # Desktop default exists, return None (no active profile)
+                return None
+
+    # Return virtual default profile if no Desktop default exists
     return AuthProfile(
         id=DEFAULT_PROFILE_ID,
         name="Local Default",
         email="admin@localhost",
-        api_url=f"http://{settings.host}:{settings.port}",
+        api_url=expected_default_url,
         is_active=True,
         created_at=datetime.now(),
         metadata=ProfileMetadata(

tests/test_profile_utils.py

@@ -638,6 +638,119 @@ def test_set_active_profile_updates_last_used(self, mock_settings) -> None:
         assert updated_store is not None
         assert updated_store.profiles["profile-1"].last_used is not None
 
+
+class TestDesktopDefaultProfile:
+    """Tests for Desktop app default profile detection."""
+
+    def test_get_all_profiles_with_desktop_default(self, mock_settings) -> None:
+        """Test that virtual default is not included when Desktop default exists."""
+        # Create a Desktop-created default profile
+        desktop_default = AuthProfile(
+            id="random-desktop-id",
+            name="Desktop Default",
+            email="admin@localhost",
+            apiUrl=f"http://{mock_settings.host}:{mock_settings.port}",
+            isActive=True,
+            createdAt=datetime.now(),
+            metadata=ProfileMetadata(
+                description="Desktop default profile",
+                environment="local",
+                is_internal=True,
+            ),
+        )
+
+        store = ProfileStore(
+            profiles={"random-desktop-id": desktop_default},
+            activeProfileId="random-desktop-id",
+        )
+        save_profile_store(store)
+
+        profiles = get_all_profiles()
+
+        # Should only have the Desktop default, not the virtual default
+        assert len(profiles) == 1
+        assert profiles[0].id == "random-desktop-id"
+        assert profiles[0].metadata.is_internal is True
+        assert not any(p.id == DEFAULT_PROFILE_ID for p in profiles)
+
+    def test_get_all_profiles_without_desktop_default(self, mock_settings) -> None:
+        """Test that virtual default is included when no Desktop default exists."""
+        # Create a non-default profile
+        profile = AuthProfile(
+            id="profile-1",
+            name="Custom Profile",
+            email="user@example.com",
+            apiUrl="https://api.example.com",
+            isActive=True,
+            createdAt=datetime.now(),
+        )
+
+        store = ProfileStore(
+            profiles={"profile-1": profile},
+            activeProfileId="profile-1",
+        )
+        save_profile_store(store)
+
+        profiles = get_all_profiles()
+
+        # Should have both the custom profile and virtual default
+        assert len(profiles) == 2
+        assert any(p.id == "profile-1" for p in profiles)
+        assert any(p.id == DEFAULT_PROFILE_ID for p in profiles)
+
+    def test_get_active_profile_with_desktop_default_inactive(self, mock_settings) -> None:
+        """Test that None is returned when Desktop default exists but is not active."""
+        # Create a Desktop-created default profile that is NOT active
+        desktop_default = AuthProfile(
+            id="random-desktop-id",
+            name="Desktop Default",
+            email="admin@localhost",
+            apiUrl=f"http://{mock_settings.host}:{mock_settings.port}",
+            isActive=False,
+            createdAt=datetime.now(),
+            metadata=ProfileMetadata(
+                description="Desktop default profile",
+                environment="local",
+                is_internal=True,
+            ),
+        )
+
+        store = ProfileStore(
+            profiles={"random-desktop-id": desktop_default},
+            activeProfileId=None,
+        )
+        save_profile_store(store)
+
+        result = get_active_profile()
+
+        # Should return None because Desktop default exists (even if not active)
+        assert result is None
+
+    def test_get_active_profile_without_desktop_default(self, mock_settings) -> None:
+        """Test that virtual default is returned when no Desktop default exists."""
+        # Create a non-default profile that is NOT active
+        profile = AuthProfile(
+            id="profile-1",
+            name="Custom Profile",
+            email="user@example.com",
+            apiUrl="https://api.example.com",
+            isActive=False,
+            createdAt=datetime.now(),
+        )
+
+        store = ProfileStore(
+            profiles={"profile-1": profile},
+            activeProfileId=None,
+        )
+        save_profile_store(store)
+
+        result = get_active_profile()
+
+        # Should return virtual default
+        assert result is not None
+        assert result.id == DEFAULT_PROFILE_ID
+        assert result.name == "Local Default"
+
     def test_set_active_profile_default_no_store(self, mock_settings) -> None:
         """Test setting active profile to the default with no store passes"""
         result = set_active_profile(DEFAULT_PROFILE_ID)