d365fo-client 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

d365fo_client/client.py

@@ -2,7 +2,6 @@
 
 import asyncio
 import logging
-import os
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
@@ -158,6 +157,17 @@ class FOClient:
             self.logger.error(f"Background sync error: {e}")
             # Don't re-raise to avoid breaking the background task
 
+    def _is_background_sync_running(self) -> bool:
+        """Check if background sync task is currently running
+
+        Returns:
+            True if background sync is actively running, False otherwise
+        """
+        return (
+            self._background_sync_task is not None
+            and not self._background_sync_task.done()
+        )
+
     async def _get_from_cache_first(
         self,
         cache_method,
@@ -179,8 +189,12 @@ class FOClient:
         if use_cache_first is None:
             use_cache_first = self.config.use_cache_first
 
-        # If cache-first is disabled, go straight to fallback
-        if not use_cache_first or not self.config.enable_metadata_cache:
+        # If cache-first is disabled, metadata cache is disabled, or background sync is running, go straight to fallback
+        if (
+            not use_cache_first
+            or not self.config.enable_metadata_cache
+            or self._is_background_sync_running()
+        ):
             return (
                 await fallback_method(*args, **kwargs)
                 if asyncio.iscoroutinefunction(fallback_method)
@@ -375,7 +389,7 @@ class FOClient:
         return await self._get_from_cache_first(
             cache_search,
             fallback_search,
-            use_cache_first=use_cache_first or self.config.use_cache_first,
+            use_cache_first=use_cache_first,
         )
 
     async def get_entity_info(
@@ -415,20 +429,34 @@ class FOClient:
         await self._ensure_metadata_initialized()
 
         async def cache_search():
-            # TODO: v2 cache doesn't have action search yet - will be implemented in future phase
-            # For now, always return empty to force fallback to API
-            return []
+            # Use the v2 cache action search functionality
+            if not self.metadata_cache:
+                return []
+
+            # Convert regex pattern to SQL LIKE pattern for cache
+            cache_pattern = None
+            if pattern:
+                # Convert simple regex to SQL LIKE pattern
+                cache_pattern = pattern.replace(".*", "%").replace(".", "_")
+                if not cache_pattern.startswith("%") and not cache_pattern.endswith("%"):
+                    cache_pattern = f"%{cache_pattern}%"
+
+            return await self.metadata_cache.search_actions(
+                pattern=cache_pattern,
+                entity_name=entity_name,
+                binding_kind=binding_kind,
+            )
 
         async def fallback_search():
-            # Actions are not directly available through metadata API
-            # They are part of entity definitions
-            # Return empty list for backward compatibility
-            return []
+            # Use the new metadata API operations for action search
+            return await self.metadata_api_ops.search_actions(
+                pattern, entity_name, binding_kind
+            )
 
         actions = await self._get_from_cache_first(
             cache_search,
             fallback_search,
-            use_cache_first=use_cache_first or self.config.use_cache_first,
+            use_cache_first=use_cache_first,
         )
 
         return await resolve_labels_generic(actions, self.label_ops)
@@ -451,20 +479,25 @@ class FOClient:
         """
 
         async def cache_lookup():
-            # TODO: v2 cache doesn't have action lookup yet - will be implemented in future phase
-            # For now, always return None to force fallback to API
-            return None
+            # Use the v2 cache action lookup functionality
+            if not self.metadata_cache:
+                return None
+
+            return await self.metadata_cache.get_action_info(
+                action_name=action_name,
+                entity_name=entity_name,
+            )
 
         async def fallback_lookup():
-            # Actions are not directly available through metadata API
-            # They are part of entity definitions
-            # Return None for backward compatibility
-            return None
+            # Use the new metadata API operations for action lookup
+            return await self.metadata_api_ops.get_action_info(action_name, entity_name)
 
-        return await self._get_from_cache_first(
+        action = await self._get_from_cache_first(
             cache_lookup, fallback_lookup, use_cache_first=use_cache_first
         )
 
+        return await resolve_labels_generic(action, self.label_ops) if action else None
+
     # CRUD Operations
 
     async def get_entities(
@@ -736,7 +769,7 @@ class FOClient:
         entities = await self._get_from_cache_first(
             cache_search,
             fallback_search,
-            use_cache_first=use_cache_first or self.config.use_cache_first,
+            use_cache_first=use_cache_first,
         )
 
         if self.metadata_cache:
@@ -861,7 +894,7 @@ class FOClient:
         entity = await self._get_from_cache_first(
             cache_lookup,
             fallback_lookup,
-            use_cache_first=use_cache_first or self.config.use_cache_first,
+            use_cache_first=use_cache_first,
         )
 
         return await resolve_labels_generic(entity, self.label_ops)
@@ -924,7 +957,7 @@ class FOClient:
         enums = await self._get_from_cache_first(
             cache_search,
             fallback_search,
-            use_cache_first=use_cache_first or self.config.use_cache_first,
+            use_cache_first=use_cache_first,
         )
 
         return await resolve_labels_generic(enums, self.label_ops)
@@ -961,7 +994,7 @@ class FOClient:
         enum = await self._get_from_cache_first(
             cache_lookup,
             fallback_lookup,
-            use_cache_first=use_cache_first or self.config.use_cache_first,
+            use_cache_first=use_cache_first,
         )
         return await resolve_labels_generic(enum, self.label_ops) if enum else None
 
@@ -1136,14 +1169,7 @@ class FOClient:
                     "cache_v2_enabled": True,
                     "cache_initialized": self._metadata_initialized,
                     "sync_manager_available": self.sync_manager is not None,
-                    "background_sync_running": (
-                        (
-                            self._background_sync_task
-                            and not self._background_sync_task.done()
-                        )
-                        if self._background_sync_task
-                        else False
-                    ),
+                    "background_sync_running": self._is_background_sync_running(),
                     "statistics": stats,
                 }
                 info.update(cache_info)

d365fo_client/config.py

@@ -69,6 +69,14 @@ class ConfigManager:
         except Exception as e:
             print(f"Error saving config file {self.config_path}: {e}")
 
+    def reload_config(self) -> None:
+        """Reload configuration from file.
+        
+        This is useful when the config file has been modified externally
+        or by another instance of the ConfigManager.
+        """
+        self._config_data = self._load_config()
+
     def get_profile(self, profile_name: str) -> Optional[Profile]:
         """Get a specific configuration profile.
 

d365fo_client/labels.py

@@ -401,14 +401,14 @@ async def _resolve_labels_batch(
         # Log individual results at debug level
         for label_id in label_ids:
             if label_id in label_texts:
-                logger.debug(f"✅ Resolved '{label_id}' -> '{label_texts[label_id]}'")
+                logger.debug(f"[OK] Resolved '{label_id}' -> '{label_texts[label_id]}'")
             else:
-                logger.debug(f"❌ No text found for label ID '{label_id}'")
+                logger.debug(f"[MISS] No text found for label ID '{label_id}'")
 
         return label_texts
 
     except Exception as e:
-        logger.warning(f"❌ Error in batch label resolution: {e}")
+        logger.warning(f"[ERROR] Error in batch label resolution: {e}")
         return {}
 
 

d365fo_client/main.py

@@ -20,26 +20,26 @@ async def example_usage():
 
     async with FOClient(config) as client:
         # Test connections
-        print("🔗 Testing connections...")
+        print("[INFO] Testing connections...")
         if await client.test_connection():
-            print("✅ Connected to F&O OData successfully")
+            print("[OK] Connected to F&O OData successfully")
 
         if await client.test_metadata_connection():
-            print("✅ Connected to F&O Metadata API successfully")
+            print("[OK] Connected to F&O Metadata API successfully")
 
         # Download metadata
         print("\n📥 Downloading metadata...")
         await client.download_metadata()
 
         # Search entities
-        print("\n🔍 Searching entities...")
+        print("\n[SEARCH] Searching entities...")
         customer_entities = await client.search_entities("customer")
         print(f"Found {len(customer_entities)} customer-related entities")
         for entity in customer_entities[:5]:  # Show first 5
             print(f"  - {entity}")
 
         # Get entity info with labels
-        print("\n📊 Getting entity information...")
+        print("\n[INFO] Getting entity information...")
         customers_info = await client.get_entity_info_with_labels("Customer")
         if customers_info:
             print(f"Customers entity: {customers_info.name}")
@@ -128,7 +128,7 @@ async def example_usage():
         print("\n🆕 New Metadata APIs:")
 
         # Data Entities API
-        print("\n📊 Data Entities API:")
+        print("\n[API] Data Entities API:")
         data_entities = await client.search_data_entities(
             "customer", entity_category="Master"
         )

d365fo_client/mcp/client_manager.py

@@ -20,17 +20,18 @@ logger = logging.getLogger(__name__)
 class D365FOClientManager:
     """Manages D365FO client instances and connection pooling."""
 
-    def __init__(self, config: dict):
+    def __init__(self, config: dict, profile_manager: Optional[ProfileManager] = None):
         """Initialize the client manager.
 
         Args:
             config: Configuration dictionary with client settings
+            profile_manager: Optional shared ProfileManager instance
         """
         self.config = config
         self._client_pool: Dict[str, FOClient] = {}
         self._session_lock = asyncio.Lock()
         self._last_health_check: Optional[datetime] = None
-        self.profile_manager = ProfileManager()
+        self.profile_manager = profile_manager or ProfileManager()
 
     async def get_client(self, profile: str = "default") -> FOClient:
         """Get or create a client for the specified profile.
@@ -144,6 +145,33 @@ class D365FOClientManager:
                         )
                 self._client_pool.clear()
 
+    async def refresh_profile(self, profile: str):
+        """Refresh a specific profile by clearing its cached client.
+        
+        This forces the client manager to recreate the client with
+        updated profile configuration on next access.
+        
+        Args:
+            profile: Profile name to refresh
+        """
+        logger.info(f"Refreshing profile: {profile}")
+        # Reload configuration to see any recent changes
+        self.profile_manager.reload_config()
+        # Clear the cached client for this profile
+        await self.cleanup(profile)
+
+    async def refresh_all_profiles(self):
+        """Refresh all profiles by clearing the entire client pool.
+        
+        This forces the client manager to recreate all clients with
+        updated profile configurations on next access.
+        """
+        logger.info("Refreshing all profiles")
+        # Reload configuration to see any recent changes
+        self.profile_manager.reload_config()
+        # Clear all cached clients
+        await self.cleanup()
+
     def _build_client_config(self, profile: str) -> FOClientConfig:
         """Build FOClientConfig from profile configuration.
 

d365fo_client/mcp/main.py

@@ -6,8 +6,9 @@ import logging
 import os
 import sys
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict
 
+from d365fo_client import __version__
 from d365fo_client.mcp import D365FOMCPServer
 
 
@@ -23,6 +24,11 @@ def setup_logging(level: str = "INFO") -> None:
     log_dir = Path.home() / ".d365fo-mcp" / "logs"
     log_dir.mkdir(parents=True, exist_ok=True)
 
+    # Clear existing handlers to avoid duplicate logging
+    root_logger = logging.getLogger()
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+
     # Configure logging
     logging.basicConfig(
         level=log_level,
@@ -31,14 +37,15 @@ def setup_logging(level: str = "INFO") -> None:
             logging.FileHandler(log_dir / "mcp-server.log"),
             logging.StreamHandler(sys.stderr),
         ],
+        force=True,  # Force reconfiguration even if logging is already configured
     )
 
 
-def load_config() -> Optional[Dict[str, Any]]:
+def load_config() -> Dict[str, Any]:
     """Load configuration from environment and config files.
 
     Returns:
-        Configuration dictionary or None for defaults
+        Configuration dictionary
     """
     config = {}
 
@@ -56,16 +63,22 @@ def load_config() -> Optional[Dict[str, Any]]:
     if tenant_id := os.getenv("AZURE_TENANT_ID"):
         config.setdefault("default_environment", {})["tenant_id"] = tenant_id
 
-    # Logging level
-    log_level = os.getenv("D365FO_LOG_LEVEL", "INFO")
-    setup_logging(log_level)
+    # Check if D365FO_BASE_URL is configured for startup behavior
+    config["has_base_url"] = bool(os.getenv("D365FO_BASE_URL"))
 
-    return config if config else None
+    return config
 
 
 async def async_main() -> None:
     """Async main entry point for the MCP server."""
     try:
+        # Set up logging first based on environment variable
+        log_level = os.getenv("D365FO_LOG_LEVEL", "INFO")
+        setup_logging(log_level)
+        
+        # Print server version at startup
+        logging.info(f"D365FO MCP Server v{__version__}")
+        
         # Load configuration
         config = load_config()
 

d365fo_client/mcp/server.py

@@ -7,6 +7,9 @@ from typing import Any, Dict, List, Optional
 
 from mcp import GetPromptResult, Resource, Tool
 from mcp.server import InitializationOptions, Server
+
+from .. import __version__
+from ..profile_manager import ProfileManager
 from mcp.server.lowlevel.server import NotificationOptions
 from mcp.types import Prompt, PromptArgument, PromptMessage, TextContent
 
@@ -36,7 +39,8 @@ class D365FOMCPServer:
         """
         self.config = config or self._load_default_config()
         self.server = Server("d365fo-mcp-server")
-        self.client_manager = D365FOClientManager(self.config)
+        self.profile_manager = ProfileManager()
+        self.client_manager = D365FOClientManager(self.config, self.profile_manager)
 
         # Initialize resource handlers
         self.entity_handler = EntityResourceHandler(self.client_manager)
@@ -321,10 +325,10 @@ class D365FOMCPServer:
             transport_type: Transport type (stdio, sse, etc.)
         """
         try:
-            logger.info("Starting D365FO MCP Server...")
+            logger.info(f"Starting D365FO MCP Server v{__version__}...")
 
-            # Perform health checks
-            await self._startup_health_checks()
+            # Perform conditional startup initialization
+            await self._startup_initialization()
 
             if transport_type == "stdio":
                 from mcp.server.stdio import stdio_server
@@ -335,7 +339,7 @@ class D365FOMCPServer:
                         write_stream,
                         InitializationOptions(
                             server_name="d365fo-mcp-server",
-                            server_version="1.0.0",
+                            server_version=__version__,
                             capabilities=self.server.get_capabilities(
                                 notification_options=NotificationOptions(),
                                 experimental_capabilities={},
@@ -351,6 +355,87 @@ class D365FOMCPServer:
         finally:
             await self.cleanup()
 
+    async def _startup_initialization(self):
+        """Perform startup initialization based on configuration."""
+        try:
+            # Check if D365FO_BASE_URL is configured
+            has_base_url = self.config.get("has_base_url", False)
+            
+            if has_base_url:
+                logger.info("D365FO_BASE_URL environment variable detected - performing health checks and profile setup")
+                
+                # Perform health checks
+                await self._startup_health_checks()
+                
+                # Create default profile if environment variables are configured
+                await self._create_default_profile_if_needed()
+            else:
+                logger.info("D365FO_BASE_URL not configured - server started in profile-only mode")
+                logger.info("Use profile management tools to configure D365FO connections")
+
+        except Exception as e:
+            logger.error(f"Startup initialization failed: {e}")
+            # Don't fail startup on initialization failures
+
+    async def _create_default_profile_if_needed(self):
+        """Create a default profile from environment variables if needed."""
+        try:
+            # Check if default profile already exists
+            existing_default = self.profile_manager.get_default_profile()
+            if existing_default:
+                logger.info(f"Default profile already exists: {existing_default.name}")
+                return
+
+            # Get environment variables
+            base_url = os.getenv("D365FO_BASE_URL")
+            client_id = os.getenv("AZURE_CLIENT_ID")
+            client_secret = os.getenv("AZURE_CLIENT_SECRET")
+            tenant_id = os.getenv("AZURE_TENANT_ID")
+
+            if not base_url:
+                logger.warning("Cannot create default profile - D365FO_BASE_URL not set")
+                return
+
+            # Determine authentication mode
+            auth_mode = "default"
+            if client_id and client_secret and tenant_id:
+                auth_mode = "client_credentials"
+
+            # Create default profile with unique name
+            profile_name = "default-from-env"
+            
+            # Check if profile with this name already exists
+            existing_profile = self.profile_manager.get_profile(profile_name)
+            if existing_profile:
+                logger.info(f"Profile '{profile_name}' already exists, setting as default")
+                self.profile_manager.set_default_profile(profile_name)
+                return
+
+            success = self.profile_manager.create_profile(
+                name=profile_name,
+                base_url=base_url,
+                auth_mode=auth_mode,
+                client_id=client_id,
+                client_secret=client_secret,
+                tenant_id=tenant_id,
+                description="Auto-created from environment variables at startup",
+                use_label_cache=True,
+                timeout=60,
+                verify_ssl=True
+            )
+
+            if success:
+                # Set as default profile
+                self.profile_manager.set_default_profile(profile_name)
+                logger.info(f"Created and set default profile: {profile_name}")
+                logger.info(f"Profile configured for: {base_url}")
+                logger.info(f"Authentication mode: {auth_mode}")
+            else:
+                logger.warning(f"Failed to create default profile: {profile_name}")
+
+        except Exception as e:
+            logger.error(f"Error creating default profile: {e}")
+
     async def _startup_health_checks(self):
         """Perform startup health checks."""
         try:

d365fo_client/mcp/tools/profile_tools.py

@@ -423,6 +423,12 @@ class ProfileTools:
             if set_as_default:
                 self.profile_manager.set_default_profile(name)
 
+            # Refresh the client manager to pick up the new profile
+            await self.client_manager.refresh_profile(name)
+            if set_as_default:
+                # If setting as default, also refresh the default profile
+                await self.client_manager.refresh_profile("default")
+
             response = {
                 "success": True,
                 "profileName": name,
@@ -485,6 +491,9 @@ class ProfileTools:
                     TextContent(type="text", text=json.dumps(error_response, indent=2))
                 ]
 
+            # Refresh the client manager to pick up the updated profile
+            await self.client_manager.refresh_profile(name)
+
             response = {
                 "success": True,
                 "profileName": name,
@@ -525,6 +534,9 @@ class ProfileTools:
                     TextContent(type="text", text=json.dumps(error_response, indent=2))
                 ]
 
+            # Refresh the client manager to remove the deleted profile
+            await self.client_manager.refresh_profile(profile_name)
+
             response = {
                 "success": True,
                 "profileName": profile_name,
@@ -564,6 +576,9 @@ class ProfileTools:
                     TextContent(type="text", text=json.dumps(error_response, indent=2))
                 ]
 
+            # Refresh the default profile in client manager
+            await self.client_manager.refresh_profile("default")
+
             response = {
                 "success": True,
                 "profileName": profile_name,