d365fo-client 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

d365fo_client/mcp/main.py

@@ -43,28 +43,50 @@ def setup_logging(level: str = "INFO") -> None:
 
 def load_config() -> Dict[str, Any]:
     """Load configuration from environment and config files.
+    
+    Handles three startup scenarios:
+    1. No environment variables: Profile-only mode
+    2. D365FO_BASE_URL only: Default auth mode
+    3. Full variables: Client credentials mode
 
     Returns:
-        Configuration dictionary
+        Configuration dictionary with startup_mode indicator
     """
     config = {}
-
-    # Load from environment variables
-    if base_url := os.getenv("D365FO_BASE_URL"):
+    
+    # Get environment variables
+    base_url = os.getenv("D365FO_BASE_URL")
+    client_id = os.getenv("D365FO_CLIENT_ID")
+    client_secret = os.getenv("D365FO_CLIENT_SECRET")
+    tenant_id = os.getenv("D365FO_TENANT_ID")
+    
+    # Determine startup mode based on available environment variables
+    if not base_url:
+        # Scenario 1: No environment variables - profile-only mode
+        config["startup_mode"] = "profile_only"
+        config["has_base_url"] = False
+        logging.info("Startup mode: profile-only (no D365FO_BASE_URL provided)")
+        
+    elif base_url and not (client_id and client_secret and tenant_id):
+        # Scenario 2: Only base URL - default authentication
+        config["startup_mode"] = "default_auth"
+        config["has_base_url"] = True
         config.setdefault("default_environment", {})["base_url"] = base_url
-
-    if client_id := os.getenv("AZURE_CLIENT_ID"):
-        config.setdefault("default_environment", {})["client_id"] = client_id
-        config["default_environment"]["use_default_credentials"] = False
-
-    if client_secret := os.getenv("AZURE_CLIENT_SECRET"):
-        config.setdefault("default_environment", {})["client_secret"] = client_secret
-
-    if tenant_id := os.getenv("AZURE_TENANT_ID"):
-        config.setdefault("default_environment", {})["tenant_id"] = tenant_id
-
-    # Check if D365FO_BASE_URL is configured for startup behavior
-    config["has_base_url"] = bool(os.getenv("D365FO_BASE_URL"))
+        config["default_environment"]["use_default_credentials"] = True
+        logging.info("Startup mode: default authentication (D365FO_BASE_URL provided)")
+        
+    else:
+        # Scenario 3: Full credentials - client credentials authentication
+        config["startup_mode"] = "client_credentials"
+        config["has_base_url"] = True
+        config.setdefault("default_environment", {}).update({
+            "base_url": base_url,
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "tenant_id": tenant_id,
+            "use_default_credentials": False
+        })
+        logging.info("Startup mode: client credentials (full D365FO environment variables provided)")
 
     return config
 

d365fo_client/mcp/server.py

@@ -8,6 +8,8 @@ from typing import Any, Dict, List, Optional
 from mcp import GetPromptResult, Resource, Tool
 from mcp.server import InitializationOptions, Server
 
+from d365fo_client.credential_sources import CredentialSource, EnvironmentCredentialSource
+
 from .. import __version__
 from ..profile_manager import ProfileManager
 from mcp.server.lowlevel.server import NotificationOptions
@@ -23,7 +25,7 @@ from .resources import (
     MetadataResourceHandler,
     QueryResourceHandler,
 )
-from .tools import ConnectionTools, CrudTools, DatabaseTools, LabelTools, MetadataTools, ProfileTools
+from .tools import ConnectionTools, CrudTools, DatabaseTools, LabelTools, MetadataTools, ProfileTools, SyncTools
 
 logger = logging.getLogger(__name__)
 
@@ -56,6 +58,7 @@ class D365FOMCPServer:
         self.label_tools = LabelTools(self.client_manager)
         self.profile_tools = ProfileTools(self.client_manager)
         self.database_tools = DatabaseTools(self.client_manager)
+        self.sync_tools = SyncTools(self.client_manager)
 
         # Tool registry for execution
         self.tool_registry = {}
@@ -215,6 +218,10 @@ class D365FOMCPServer:
                 database_tools = self.database_tools.get_tools()
                 tools.extend(database_tools)
 
+                # Add sync tools
+                sync_tools = self.sync_tools.get_tools()
+                tools.extend(sync_tools)
+
                 # Register tools for execution
                 for tool in tools:
                     self.tool_registry[tool.name] = tool
@@ -310,6 +317,16 @@ class D365FOMCPServer:
                     return await self.database_tools.execute_get_table_info(arguments)
                 elif name == "d365fo_get_database_statistics":
                     return await self.database_tools.execute_get_database_statistics(arguments)
+                elif name == "d365fo_start_sync":
+                    return await self.sync_tools.execute_start_sync(arguments)
+                elif name == "d365fo_get_sync_progress":
+                    return await self.sync_tools.execute_get_sync_progress(arguments)
+                elif name == "d365fo_cancel_sync":
+                    return await self.sync_tools.execute_cancel_sync(arguments)
+                elif name == "d365fo_list_sync_sessions":
+                    return await self.sync_tools.execute_list_sync_sessions(arguments)
+                elif name == "d365fo_get_sync_history":
+                    return await self.sync_tools.execute_get_sync_history(arguments)
                 else:
                     raise ValueError(f"Unknown tool: {name}")
 
@@ -358,24 +375,34 @@ class D365FOMCPServer:
     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)
+            startup_mode = self.config.get("startup_mode", "profile_only")
             
-            if has_base_url:
-                logger.info("D365FO_BASE_URL environment variable detected - performing health checks and profile setup")
+            if startup_mode == "profile_only":
+                logger.info("Server started in profile-only mode")
+                logger.info("No environment variables configured - use profile management tools to configure D365FO connections")
+                
+            elif startup_mode == "default_auth":
+                logger.info("Server started with default authentication mode")
+                logger.info("D365FO_BASE_URL configured - performing health checks and creating default profile with default auth")
                 
-                # Perform health checks
+                # Perform health checks and create default profile
                 await self._startup_health_checks()
+                await self._create_default_profile_if_needed()
+                
+            elif startup_mode == "client_credentials":
+                logger.info("Server started with client credentials authentication mode")
+                logger.info("Full D365FO environment variables configured - performing health checks and creating default profile with client credentials")
                 
-                # Create default profile if environment variables are configured
+                # Perform health checks and create default profile
+                await self._startup_health_checks()
                 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")
+                logger.warning(f"Unknown startup mode: {startup_mode}")
 
         except Exception as e:
             logger.error(f"Startup initialization failed: {e}")
-            # Don't fail startup on initialization failures
+            # Don't fail startup on initialization failures - allow server to start in profile-only mode
 
     async def _create_default_profile_if_needed(self):
         """Create a default profile from environment variables if needed."""
@@ -386,20 +413,30 @@ class D365FOMCPServer:
                 logger.info(f"Default profile already exists: {existing_default.name}")
                 return
 
-            # Get environment variables
+            # Get environment variables with correct names
             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")
+            client_id = os.getenv("D365FO_CLIENT_ID")
+            client_secret = os.getenv("D365FO_CLIENT_SECRET")
+            tenant_id = os.getenv("D365FO_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:
+            # Determine authentication mode based on startup mode
+            startup_mode = self.config.get("startup_mode", "profile_only")
+            
+            if startup_mode == "client_credentials":
                 auth_mode = "client_credentials"
+                if not all([client_id, client_secret, tenant_id]):
+                    logger.error("Client credentials mode requires D365FO_CLIENT_ID, D365FO_CLIENT_SECRET, and D365FO_TENANT_ID")
+                    return
+            else:
+                auth_mode = "default"
+                # Clear client credentials for default auth mode
+                client_id = None
+                client_secret = None
+                tenant_id = None
 
             # Create default profile with unique name
             profile_name = "default-from-env"
@@ -411,17 +448,22 @@ class D365FOMCPServer:
                 self.profile_manager.set_default_profile(profile_name)
                 return
 
+            credential_source = None
+            if startup_mode == "client_credentials":
+                credential_source = EnvironmentCredentialSource()
+
             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",
+                client_id=None, #use from env var
+                client_secret=None, #use from env var
+                tenant_id=None, #use from env var
+                description=f"Auto-created from environment variables at startup (mode: {startup_mode})",
                 use_label_cache=True,
                 timeout=60,
-                verify_ssl=True
+                verify_ssl=True,
+                credential_source=credential_source
             )
 
             if success:
@@ -430,6 +472,11 @@ class D365FOMCPServer:
                 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}")
+                
+                if auth_mode == "client_credentials":
+                    logger.info(f"Client ID: {client_id}")
+                    logger.info(f"Tenant ID: {tenant_id}")
+                    
             else:
                 logger.warning(f"Failed to create default profile: {profile_name}")
 

d365fo_client/mcp/tools/__init__.py

@@ -6,6 +6,7 @@ from .database_tools import DatabaseTools
 from .label_tools import LabelTools
 from .metadata_tools import MetadataTools
 from .profile_tools import ProfileTools
+from .sync_tools import SyncTools
 
 __all__ = [
     "ConnectionTools",
@@ -14,4 +15,5 @@ __all__ = [
     "LabelTools",
     "ProfileTools",
     "DatabaseTools",
+    "SyncTools",
 ]

d365fo_client/mcp/tools/profile_tools.py

@@ -96,6 +96,81 @@ class ProfileTools:
                         "type": "string",
                         "description": "Azure tenant ID (for client_credentials auth)",
                     },
+                    "credentialSource": {
+                        "type": "object",
+                        "description": "Credential source configuration",
+                        "properties": {
+                            "sourceType": {
+                                "type": "string",
+                                "description": "Type of credential source",
+                                "enum": ["environment", "keyvault"]
+                            },
+                            "clientIdVar": {
+                                "type": "string",
+                                "description": "Environment variable name for client ID (environment source)",
+                                "default": "D365FO_CLIENT_ID"
+                            },
+                            "clientSecretVar": {
+                                "type": "string",
+                                "description": "Environment variable name for client secret (environment source)",
+                                "default": "D365FO_CLIENT_SECRET"
+                            },
+                            "tenantIdVar": {
+                                "type": "string",
+                                "description": "Environment variable name for tenant ID (environment source)",
+                                "default": "D365FO_TENANT_ID"
+                            },
+                            "vaultUrl": {
+                                "type": "string",
+                                "description": "Azure Key Vault URL (keyvault source)"
+                            },
+                            "clientIdSecretName": {
+                                "type": "string",
+                                "description": "Key Vault secret name for client ID (keyvault source)",
+                                "default": "D365FO_CLIENT_ID"
+                            },
+                            "clientSecretSecretName": {
+                                "type": "string",
+                                "description": "Key Vault secret name for client secret (keyvault source)",
+                                "default": "D365FO_CLIENT_SECRET"
+                            },
+                            "tenantIdSecretName": {
+                                "type": "string",
+                                "description": "Key Vault secret name for tenant ID (keyvault source)",
+                                "default": "D365FO_TENANT_ID"
+                            },
+                            "keyvaultAuthMode": {
+                                "type": "string",
+                                "description": "Key Vault authentication mode",
+                                "enum": ["default", "client_secret"],
+                                "default": "default"
+                            },
+                            "keyvaultClientId": {
+                                "type": "string",
+                                "description": "Client ID for Key Vault authentication (client_secret mode)"
+                            },
+                            "keyvaultClientSecret": {
+                                "type": "string",
+                                "description": "Client secret for Key Vault authentication (client_secret mode)"
+                            },
+                            "keyvaultTenantId": {
+                                "type": "string",
+                                "description": "Tenant ID for Key Vault authentication (client_secret mode)"
+                            }
+                        },
+                        "required": ["sourceType"],
+                        "anyOf": [
+                            {
+                                "properties": {"sourceType": {"const": "environment"}},
+                                "additionalProperties": True
+                            },
+                            {
+                                "properties": {"sourceType": {"const": "keyvault"}},
+                                "required": ["vaultUrl"],
+                                "additionalProperties": True
+                            }
+                        ]
+                    },
                     "verifySsl": {
                         "type": "boolean",
                         "description": "Whether to verify SSL certificates",
@@ -163,6 +238,81 @@ class ProfileTools:
                         "description": "Azure client secret",
                     },
                     "tenantId": {"type": "string", "description": "Azure tenant ID"},
+                    "credentialSource": {
+                        "type": "object",
+                        "description": "Credential source configuration",
+                        "properties": {
+                            "sourceType": {
+                                "type": "string",
+                                "description": "Type of credential source",
+                                "enum": ["environment", "keyvault"]
+                            },
+                            "clientIdVar": {
+                                "type": "string",
+                                "description": "Environment variable name for client ID (environment source)",
+                                "default": "D365FO_CLIENT_ID"
+                            },
+                            "clientSecretVar": {
+                                "type": "string",
+                                "description": "Environment variable name for client secret (environment source)",
+                                "default": "D365FO_CLIENT_SECRET"
+                            },
+                            "tenantIdVar": {
+                                "type": "string",
+                                "description": "Environment variable name for tenant ID (environment source)",
+                                "default": "D365FO_TENANT_ID"
+                            },
+                            "vaultUrl": {
+                                "type": "string",
+                                "description": "Azure Key Vault URL (keyvault source)"
+                            },
+                            "clientIdSecretName": {
+                                "type": "string",
+                                "description": "Key Vault secret name for client ID (keyvault source)",
+                                "default": "D365FO_CLIENT_ID"
+                            },
+                            "clientSecretSecretName": {
+                                "type": "string",
+                                "description": "Key Vault secret name for client secret (keyvault source)",
+                                "default": "D365FO_CLIENT_SECRET"
+                            },
+                            "tenantIdSecretName": {
+                                "type": "string",
+                                "description": "Key Vault secret name for tenant ID (keyvault source)",
+                                "default": "D365FO_TENANT_ID"
+                            },
+                            "keyvaultAuthMode": {
+                                "type": "string",
+                                "description": "Key Vault authentication mode",
+                                "enum": ["default", "client_secret"],
+                                "default": "default"
+                            },
+                            "keyvaultClientId": {
+                                "type": "string",
+                                "description": "Client ID for Key Vault authentication (client_secret mode)"
+                            },
+                            "keyvaultClientSecret": {
+                                "type": "string",
+                                "description": "Client secret for Key Vault authentication (client_secret mode)"
+                            },
+                            "keyvaultTenantId": {
+                                "type": "string",
+                                "description": "Tenant ID for Key Vault authentication (client_secret mode)"
+                            }
+                        },
+                        "required": ["sourceType"],
+                        "anyOf": [
+                            {
+                                "properties": {"sourceType": {"const": "environment"}},
+                                "additionalProperties": True
+                            },
+                            {
+                                "properties": {"sourceType": {"const": "keyvault"}},
+                                "required": ["vaultUrl"],
+                                "additionalProperties": True
+                            }
+                        ]
+                    },
                     "verifySsl": {
                         "type": "boolean",
                         "description": "Whether to verify SSL certificates",
@@ -299,6 +449,11 @@ class ProfileTools:
                     "isDefault": default_profile and default_profile.name == name,
                     "description": profile.description,
                 }
+                
+                # Add credential source type if available
+                if profile.credential_source:
+                    profile_info["credentialSourceType"] = profile.credential_source.source_type
+                
                 profile_list.append(profile_info)
 
             response = {
@@ -356,6 +511,37 @@ class ProfileTools:
             if profile.tenant_id:
                 profile_dict["tenantId"] = profile.tenant_id
 
+            # Add credential source information if available
+            if profile.credential_source:
+                cred_source_dict = profile.credential_source.to_dict()
+                # Convert to camelCase for JSON response
+                credential_source = {
+                    "sourceType": cred_source_dict.get("source_type"),
+                }
+                
+                if cred_source_dict.get("source_type") == "environment":
+                    credential_source.update({
+                        "clientIdVar": cred_source_dict.get("client_id_var"),
+                        "clientSecretVar": cred_source_dict.get("client_secret_var"),
+                        "tenantIdVar": cred_source_dict.get("tenant_id_var"),
+                    })
+                elif cred_source_dict.get("source_type") == "keyvault":
+                    credential_source.update({
+                        "vaultUrl": cred_source_dict.get("vault_url"),
+                        "clientIdSecretName": cred_source_dict.get("client_id_secret_name"),
+                        "clientSecretSecretName": cred_source_dict.get("client_secret_secret_name"),
+                        "tenantIdSecretName": cred_source_dict.get("tenant_id_secret_name"),
+                        "keyvaultAuthMode": cred_source_dict.get("keyvault_auth_mode"),
+                    })
+                    # Only include auth details if using client_secret mode
+                    if cred_source_dict.get("keyvault_auth_mode") == "client_secret":
+                        credential_source.update({
+                            "keyvaultClientId": cred_source_dict.get("keyvault_client_id"),
+                            "keyvaultTenantId": cred_source_dict.get("keyvault_tenant_id"),
+                        })
+                
+                profile_dict["credentialSource"] = credential_source
+
             return [TextContent(type="text", text=json.dumps(profile_dict, indent=2))]
 
         except Exception as e:
@@ -393,6 +579,42 @@ class ProfileTools:
             description = arguments.get("description")
             set_as_default = arguments.get("setAsDefault", False)
 
+            # Handle credential source
+            credential_source = None
+            if "credentialSource" in arguments:
+                from ...credential_sources import create_credential_source
+                cred_source_data = arguments["credentialSource"]
+                
+                # Convert camelCase to snake_case for the factory function
+                source_type = cred_source_data["sourceType"]
+                kwargs = {}
+                
+                if source_type == "environment":
+                    if "clientIdVar" in cred_source_data:
+                        kwargs["client_id_var"] = cred_source_data["clientIdVar"]
+                    if "clientSecretVar" in cred_source_data:
+                        kwargs["client_secret_var"] = cred_source_data["clientSecretVar"]
+                    if "tenantIdVar" in cred_source_data:
+                        kwargs["tenant_id_var"] = cred_source_data["tenantIdVar"]
+                elif source_type == "keyvault":
+                    kwargs["vault_url"] = cred_source_data["vaultUrl"]
+                    if "clientIdSecretName" in cred_source_data:
+                        kwargs["client_id_secret_name"] = cred_source_data["clientIdSecretName"]
+                    if "clientSecretSecretName" in cred_source_data:
+                        kwargs["client_secret_secret_name"] = cred_source_data["clientSecretSecretName"]
+                    if "tenantIdSecretName" in cred_source_data:
+                        kwargs["tenant_id_secret_name"] = cred_source_data["tenantIdSecretName"]
+                    if "keyvaultAuthMode" in cred_source_data:
+                        kwargs["keyvault_auth_mode"] = cred_source_data["keyvaultAuthMode"]
+                    if "keyvaultClientId" in cred_source_data:
+                        kwargs["keyvault_client_id"] = cred_source_data["keyvaultClientId"]
+                    if "keyvaultClientSecret" in cred_source_data:
+                        kwargs["keyvault_client_secret"] = cred_source_data["keyvaultClientSecret"]
+                    if "keyvaultTenantId" in cred_source_data:
+                        kwargs["keyvault_tenant_id"] = cred_source_data["keyvaultTenantId"]
+                
+                credential_source = create_credential_source(source_type, **kwargs)
+
             # Create profile
             success = self.profile_manager.create_profile(
                 name=name,
@@ -408,6 +630,7 @@ class ProfileTools:
                 language=language,
                 cache_dir=cache_dir,
                 description=description,
+                credential_source=credential_source,
             )
 
             if not success:
@@ -477,8 +700,44 @@ class ProfileTools:
 
             mapped_params = {}
             for key, value in update_params.items():
-                mapped_key = param_mapping.get(key, key)
-                mapped_params[mapped_key] = value
+                if key == "credentialSource":
+                    # Handle credential source
+                    from ...credential_sources import create_credential_source
+                    cred_source_data = value
+                    
+                    # Convert camelCase to snake_case for the factory function
+                    source_type = cred_source_data["sourceType"]
+                    kwargs = {}
+                    
+                    if source_type == "environment":
+                        if "clientIdVar" in cred_source_data:
+                            kwargs["client_id_var"] = cred_source_data["clientIdVar"]
+                        if "clientSecretVar" in cred_source_data:
+                            kwargs["client_secret_var"] = cred_source_data["clientSecretVar"]
+                        if "tenantIdVar" in cred_source_data:
+                            kwargs["tenant_id_var"] = cred_source_data["tenantIdVar"]
+                    elif source_type == "keyvault":
+                        kwargs["vault_url"] = cred_source_data["vaultUrl"]
+                        if "clientIdSecretName" in cred_source_data:
+                            kwargs["client_id_secret_name"] = cred_source_data["clientIdSecretName"]
+                        if "clientSecretSecretName" in cred_source_data:
+                            kwargs["client_secret_secret_name"] = cred_source_data["clientSecretSecretName"]
+                        if "tenantIdSecretName" in cred_source_data:
+                            kwargs["tenant_id_secret_name"] = cred_source_data["tenantIdSecretName"]
+                        if "keyvaultAuthMode" in cred_source_data:
+                            kwargs["keyvault_auth_mode"] = cred_source_data["keyvaultAuthMode"]
+                        if "keyvaultClientId" in cred_source_data:
+                            kwargs["keyvault_client_id"] = cred_source_data["keyvaultClientId"]
+                        if "keyvaultClientSecret" in cred_source_data:
+                            kwargs["keyvault_client_secret"] = cred_source_data["keyvaultClientSecret"]
+                        if "keyvaultTenantId" in cred_source_data:
+                            kwargs["keyvault_tenant_id"] = cred_source_data["keyvaultTenantId"]
+                    
+                    credential_source = create_credential_source(source_type, **kwargs)
+                    mapped_params["credential_source"] = credential_source
+                else:
+                    mapped_key = param_mapping.get(key, key)
+                    mapped_params[mapped_key] = value
 
             success = self.profile_manager.update_profile(name, **mapped_params)