meta-ads-mcp 0.3.6__py3-none-any.whl → 0.3.8__py3-none-any.whl

meta_ads_mcp/__init__.py

@@ -7,7 +7,7 @@ with the Claude LLM.
 
 from meta_ads_mcp.core.server import main
 
-__version__ = "0.3.6"
+__version__ = "0.3.8"
 
 __all__ = [
     'get_ad_accounts',

meta_ads_mcp/core/api.py

@@ -206,6 +206,9 @@ def meta_api_tool(func):
                         if (auth_manager.app_id == "YOUR_META_APP_ID" or not auth_manager.app_id) and not auth_manager.use_pipeboard:
                             logger.error("TOKEN VALIDATION FAILED: No valid app_id configured")
                             logger.error("Please set META_APP_ID environment variable or configure in your code")
+                        elif auth_manager.use_pipeboard:
+                            logger.error("TOKEN VALIDATION FAILED: Pipeboard authentication enabled but no valid token available")
+                            logger.error("Complete authentication via Pipeboard service or check PIPEBOARD_API_TOKEN")
                         else:
                             logger.error("Check logs above for detailed token validation failures")
                 except Exception as e:
@@ -221,16 +224,21 @@ def meta_api_tool(func):
                 # Add more specific troubleshooting information
                 auth_url = auth_manager.get_auth_url()
                 app_id = auth_manager.app_id
+                using_pipeboard = auth_manager.use_pipeboard
                 
                 logger.error("TOKEN VALIDATION SUMMARY:")
                 logger.error(f"- Current app_id: '{app_id}'")
                 logger.error(f"- Environment META_APP_ID: '{os.environ.get('META_APP_ID', 'Not set')}'")
                 logger.error(f"- Pipeboard API token configured: {'Yes' if os.environ.get('PIPEBOARD_API_TOKEN') else 'No'}")
+                logger.error(f"- Using Pipeboard authentication: {'Yes' if using_pipeboard else 'No'}")
                 
-                # Check for common configuration issues
-                if app_id == "YOUR_META_APP_ID" or not app_id:
+                # Check for common configuration issues - but only if not using Pipeboard
+                if not using_pipeboard and (app_id == "YOUR_META_APP_ID" or not app_id):
                     logger.error("ISSUE DETECTED: No valid Meta App ID configured")
                     logger.error("ACTION REQUIRED: Set META_APP_ID environment variable with a valid App ID")
+                elif using_pipeboard:
+                    logger.error("ISSUE DETECTED: Pipeboard authentication configured but no valid token available")
+                    logger.error("ACTION REQUIRED: Complete authentication via Pipeboard service")
                 
                 return json.dumps({
                     "error": {

meta_ads_mcp/core/authentication.py

@@ -116,7 +116,7 @@ async def get_login_link(access_token: str = None) -> str:
             "authentication_method": "meta_oauth",
             "token_exchange_message": f"Your authentication token will be valid for approximately {token_duration}." + 
                                     (" Long-lived token exchange is enabled." if token_exchange_supported else 
-                                    " To enable long-lived tokens (60 days), set the META_APP_SECRET environment variable."),
+                                    " For direct Meta authentication, long-lived tokens require META_APP_SECRET. Consider using Pipeboard authentication instead (60-day tokens by default)."),
             "note": "After authenticating, the token will be automatically saved."
         }
         

meta_ads_mcp/core/campaigns.py

@@ -9,7 +9,7 @@ from .server import mcp_server
 
 @mcp_server.tool()
 @meta_api_tool
-async def get_campaigns(access_token: str = None, account_id: str = None, limit: int = 10, status_filter: str = "") -> str:
+async def get_campaigns(access_token: str = None, account_id: str = None, limit: int = 10, status_filter: str = "", after: str = "") -> str:
     """
     Get campaigns for a Meta Ads account with optional filtering.
     
@@ -26,6 +26,7 @@ async def get_campaigns(access_token: str = None, account_id: str = None, limit:
         status_filter: Filter by effective status (e.g., 'ACTIVE', 'PAUSED', 'ARCHIVED').
                        Maps to the 'effective_status' API parameter, which expects an array
                        (this function handles the required JSON formatting). Leave empty for all statuses.
+        after: Pagination cursor to get the next set of results
     """
     # If no account ID is specified, try to get the first one for the user
     if not account_id:
@@ -47,6 +48,9 @@ async def get_campaigns(access_token: str = None, account_id: str = None, limit:
         # API expects an array, encode it as a JSON string
         params["effective_status"] = json.dumps([status_filter])
     
+    if after:
+        params["after"] = after
+    
     data = await make_api_request(endpoint, access_token, params)
     
     return json.dumps(data, indent=2)

meta_ads_mcp/core/http_auth_integration.py

@@ -0,0 +1,248 @@
+"""
+FastMCP HTTP Authentication Integration for Meta Ads MCP
+
+This module provides direct integration with FastMCP to inject authentication
+from HTTP headers into the tool execution context.
+"""
+
+import asyncio
+import contextvars
+from typing import Optional
+from .utils import logger
+import json
+
+# Use context variables instead of thread-local storage for better async support
+_auth_token: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar('auth_token', default=None)
+
+class FastMCPAuthIntegration:
+    """Direct integration with FastMCP for HTTP authentication"""
+    
+    @staticmethod
+    def set_auth_token(token: str) -> None:
+        """Set authentication token for the current context
+        
+        Args:
+            token: Access token to use for this request
+        """
+        _auth_token.set(token)
+    
+    @staticmethod
+    def get_auth_token() -> Optional[str]:
+        """Get authentication token for the current context
+        
+        Returns:
+            Access token if set, None otherwise
+        """
+        return _auth_token.get(None)
+    
+    @staticmethod
+    def clear_auth_token() -> None:
+        """Clear authentication token for the current context"""
+        _auth_token.set(None)
+    
+    @staticmethod
+    def extract_token_from_headers(headers: dict) -> Optional[str]:
+        """Extract token from HTTP headers
+        
+        Args:
+            headers: HTTP request headers
+            
+        Returns:
+            Token if found, None otherwise
+        """
+        # Check for Bearer token in Authorization header (primary method)
+        auth_header = headers.get('Authorization') or headers.get('authorization')
+        if auth_header and auth_header.lower().startswith('bearer '):
+            token = auth_header[7:].strip()
+            logger.debug("Found Bearer token in Authorization header")
+            return token
+        
+        # Check for direct Meta access token
+        meta_token = headers.get('X-META-ACCESS-TOKEN') or headers.get('x-meta-access-token')
+        if meta_token:
+            return meta_token
+        
+        # Check for Pipeboard token (legacy support, to be removed)
+        pipeboard_token = headers.get('X-PIPEBOARD-API-TOKEN') or headers.get('x-pipeboard-api-token')
+        if pipeboard_token:
+            logger.debug("Found Pipeboard token in legacy headers")
+            return pipeboard_token
+        
+        return None
+
+def patch_fastmcp_server(mcp_server):
+    """Patch FastMCP server to inject authentication from HTTP headers
+    
+    Args:
+        mcp_server: FastMCP server instance to patch
+    """
+    logger.info("Patching FastMCP server for HTTP authentication")
+    
+    # Store the original run method
+    original_run = mcp_server.run
+    
+    def patched_run(transport="stdio", **kwargs):
+        """Enhanced run method that sets up HTTP auth integration"""
+        logger.debug(f"Starting FastMCP with transport: {transport}")
+        
+        if transport == "streamable-http":
+            logger.debug("Setting up HTTP authentication for streamable-http transport")
+            setup_http_auth_patching()
+        
+        # Call the original run method
+        return original_run(transport=transport, **kwargs)
+    
+    # Replace the run method
+    mcp_server.run = patched_run
+    logger.info("FastMCP server patching complete")
+
+def setup_http_auth_patching():
+    """Setup HTTP authentication patching for auth system"""
+    logger.info("Setting up HTTP authentication patching")
+    
+    # Import and patch the auth system
+    from . import auth
+    from . import api
+    from . import authentication
+    
+    # Store the original function
+    original_get_current_access_token = auth.get_current_access_token
+    
+    async def get_current_access_token_with_http_support() -> Optional[str]:
+        """Enhanced get_current_access_token that checks HTTP context first"""
+        
+        # Check for context-scoped token first
+        context_token = FastMCPAuthIntegration.get_auth_token()
+        if context_token:
+            return context_token
+        
+        # Fall back to original implementation
+        return await original_get_current_access_token()
+    
+    # Replace the function in all modules that imported it
+    auth.get_current_access_token = get_current_access_token_with_http_support
+    api.get_current_access_token = get_current_access_token_with_http_support
+    authentication.get_current_access_token = get_current_access_token_with_http_support
+    
+    logger.info("Auth system patching complete - patched in auth, api, and authentication modules")
+
+# Global instance for easy access
+fastmcp_auth = FastMCPAuthIntegration()
+
+# Forward declaration of setup_starlette_middleware
+def setup_starlette_middleware(app):
+    pass
+
+def setup_fastmcp_http_auth(mcp_server):
+    """Setup HTTP authentication integration with FastMCP
+    
+    Args:
+        mcp_server: FastMCP server instance to configure
+    """
+    logger.info("Setting up FastMCP HTTP authentication integration")
+    
+    # 1. Patch FastMCP's run method to ensure our get_current_access_token patch is applied
+    # This remains crucial for the token to be picked up by tool calls.
+    patch_fastmcp_server(mcp_server) # This patches mcp_server.run
+    
+    # 2. Patch the methods that provide the Starlette app instance
+    # This ensures our middleware is added to the app Uvicorn will actually serve.
+
+    app_provider_methods = []
+    if mcp_server.settings.json_response:
+        if hasattr(mcp_server, "streamable_http_app") and callable(mcp_server.streamable_http_app):
+            app_provider_methods.append("streamable_http_app")
+        else:
+            logger.warning("mcp_server.streamable_http_app not found or not callable, cannot patch for JSON responses.")
+    else: # SSE
+        if hasattr(mcp_server, "sse_app") and callable(mcp_server.sse_app):
+            app_provider_methods.append("sse_app")
+        else:
+            logger.warning("mcp_server.sse_app not found or not callable, cannot patch for SSE responses.")
+
+    if not app_provider_methods:
+        logger.error("No suitable app provider method (streamable_http_app or sse_app) found on mcp_server. Cannot add HTTP Auth middleware.")
+        # Fallback or error handling might be needed here if this is critical
+    
+    for method_name in app_provider_methods:
+        original_app_provider_method = getattr(mcp_server, method_name)
+        
+        def new_patched_app_provider_method(*args, **kwargs):
+            # Call the original method to get/create the Starlette app
+            app = original_app_provider_method(*args, **kwargs)
+            if app:
+                logger.debug(f"Original {method_name} returned app: {type(app)}. Adding AuthInjectionMiddleware.")
+                # Now, add our middleware to this specific app instance
+                setup_starlette_middleware(app) 
+            else:
+                logger.error(f"Original {method_name} returned None or a non-app object.")
+            return app
+            
+        setattr(mcp_server, method_name, new_patched_app_provider_method)
+        logger.debug(f"Patched mcp_server.{method_name} to inject AuthInjectionMiddleware.")
+
+    # The old setup_request_middleware call is no longer needed here,
+    # as middleware addition is now handled by patching the app provider methods.
+    # try:
+    #     setup_request_middleware(mcp_server) 
+    # except Exception as e:
+    #     logger.warning(f"Could not setup request middleware: {e}")
+
+    logger.info("FastMCP HTTP authentication integration setup attempt complete.")
+
+# Remove the old setup_request_middleware function as its logic is integrated above
+# def setup_request_middleware(mcp_server): ... (delete this function)
+
+# --- AuthInjectionMiddleware definition ---
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+import json # Ensure json is imported if not already at the top
+
+class AuthInjectionMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        logger.debug(f"HTTP Auth Middleware: Processing request to {request.url.path}")
+        logger.debug(f"HTTP Auth Middleware: Request headers: {list(request.headers.keys())}")
+        
+        token = FastMCPAuthIntegration.extract_token_from_headers(dict(request.headers))
+        
+        if token:
+            logger.debug(f"HTTP Auth Middleware: Extracted token: {token[:10]}...")
+            logger.debug("Injecting auth token into request context")
+            FastMCPAuthIntegration.set_auth_token(token)
+        else:
+            logger.warning("HTTP Auth Middleware: No authentication token found in headers")
+        
+        try:
+            response = await call_next(request)
+            return response
+        finally:
+            if token: # Clear only if a token was set for this request
+                FastMCPAuthIntegration.clear_auth_token()
+
+def setup_starlette_middleware(app):
+    """Add AuthInjectionMiddleware to the Starlette app if not already present.
+    
+    Args:
+        app: Starlette app instance
+    """
+    if not app:
+        logger.error("Cannot setup Starlette middleware, app is None.")
+        return
+
+    # Check if our specific middleware class is already in the stack
+    already_added = False
+    # Starlette's app.middleware is a list of Middleware objects.
+    # app.user_middleware contains middleware added by app.add_middleware()
+    for middleware_item in app.user_middleware:
+        if middleware_item.cls == AuthInjectionMiddleware:
+            already_added = True
+            break
+            
+    if not already_added:
+        try:
+            app.add_middleware(AuthInjectionMiddleware)
+            logger.info("AuthInjectionMiddleware added to Starlette app successfully.")
+        except Exception as e:
+            logger.error(f"Failed to add AuthInjectionMiddleware to Starlette app: {e}", exc_info=True)
+    else:
+        logger.debug("AuthInjectionMiddleware already present in Starlette app's middleware stack.") 

meta_ads_mcp/core/server.py

@@ -5,6 +5,8 @@ import argparse
 import os
 import sys
 import webbrowser
+import json
+from typing import Dict, Any, Optional
 from .auth import login as login_auth
 from .resources import list_resources, get_resource
 from .utils import logger
@@ -19,6 +21,173 @@ mcp_server.resource(uri="meta-ads://resources")(list_resources)
 mcp_server.resource(uri="meta-ads://images/{resource_id}")(get_resource)
 
 
+class StreamableHTTPHandler:
+    """Handles stateless Streamable HTTP requests for Meta Ads MCP"""
+    
+    def __init__(self):
+        """Initialize handler with no session storage - all auth per request"""
+        logger.debug("StreamableHTTPHandler initialized for stateless operation")
+        
+    def handle_request(self, request_headers: Dict[str, str], request_body: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle individual request with authentication
+        
+        Args:
+            request_headers: HTTP request headers
+            request_body: JSON-RPC request body
+            
+        Returns:
+            JSON response with auth status and any tool results
+        """
+        try:
+            # Extract authentication configuration from headers
+            auth_config = self.get_auth_config_from_headers(request_headers)
+            logger.debug(f"Auth method detected: {auth_config['auth_method']}")
+            
+            # Handle based on auth method
+            if auth_config['auth_method'] == 'bearer':
+                return self.handle_bearer_request(auth_config, request_body)
+            elif auth_config['auth_method'] == 'custom_meta_app':
+                return self.handle_custom_app_request(auth_config, request_body)
+            else:
+                return self.handle_unauthenticated_request(request_body)
+                
+        except Exception as e:
+            logger.error(f"Error handling request: {e}")
+            return {
+                'jsonrpc': '2.0',
+                'error': {
+                    'code': -32603,
+                    'message': 'Internal error',
+                    'data': str(e)
+                },
+                'id': request_body.get('id')
+            }
+    
+    def get_auth_config_from_headers(self, request_headers: Dict[str, str]) -> Dict[str, Any]:
+        """Extract authentication configuration from HTTP headers
+        
+        Args:
+            request_headers: HTTP request headers
+            
+        Returns:
+            Dictionary with auth method and relevant credentials
+        """
+        # Security validation - only allow safe headers
+        ALLOWED_VIA_HEADERS = {
+            'pipeboard_api_token': True,   # ✅ Primary method - simple and secure
+            'meta_app_id': True,           # ✅ Fallback only - triggers OAuth complexity
+            'meta_app_secret': False,      # ❌ Server environment only
+            'meta_access_token': False,    # ❌ Use proper auth flows instead
+        }
+        
+        # PRIMARY: Check for Bearer token in Authorization header (handles 90%+ of cases)
+        auth_header = request_headers.get('Authorization') or request_headers.get('authorization')
+        if auth_header and auth_header.lower().startswith('bearer '):
+            token = auth_header[7:].strip()
+            logger.info("Bearer authentication detected (primary path)")
+            return {
+                'auth_method': 'bearer',
+                'bearer_token': token,
+                'requires_oauth': False  # Simple token-based auth
+            }
+        
+        # FALLBACK: Custom Meta app (minority of users)
+        meta_app_id = request_headers.get('X-META-APP-ID') or request_headers.get('x-meta-app-id')
+        if meta_app_id:
+            logger.debug("Custom Meta app authentication detected (fallback path)")
+            return {
+                'auth_method': 'custom_meta_app',
+                'meta_app_id': meta_app_id,
+                'requires_oauth': True  # Complex OAuth flow required
+            }
+        
+        # No authentication provided
+        logger.warning("No authentication method detected in headers")
+        return {
+            'auth_method': 'none',
+            'requires_oauth': False
+        }
+    
+    def handle_bearer_request(self, auth_config: Dict[str, Any], request_body: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle request with Bearer token (primary path)
+        
+        Args:
+            auth_config: Authentication configuration from headers
+            request_body: JSON-RPC request body
+            
+        Returns:
+            JSON response ready for tool execution
+        """
+        logger.debug("Processing Bearer authenticated request")
+        token = auth_config['bearer_token']
+        
+        # Token is ready to use immediately for API calls
+        # TODO: In next phases, this will execute the actual tool call
+        return {
+            'jsonrpc': '2.0',
+            'result': {
+                'status': 'ready',
+                'auth_method': 'bearer',
+                'message': 'Authentication successful with Bearer token',
+                'token_source': 'bearer_header'
+            },
+            'id': request_body.get('id')
+        }
+    
+    def handle_custom_app_request(self, auth_config: Dict[str, Any], request_body: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle request with custom Meta app (fallback path)
+        
+        Args:
+            auth_config: Authentication configuration from headers
+            request_body: JSON-RPC request body
+            
+        Returns:
+            JSON response indicating OAuth flow is required
+        """
+        logger.debug("Processing custom Meta app request (OAuth required)")
+        
+        # This may require OAuth flow initiation
+        # Each request is independent - no session state
+        return {
+            'jsonrpc': '2.0',
+            'result': {
+                'status': 'oauth_required',
+                'auth_method': 'custom_meta_app',
+                'meta_app_id': auth_config['meta_app_id'],
+                'message': 'OAuth flow required for custom Meta app authentication',
+                'next_steps': 'Use get_login_link tool to initiate OAuth flow'
+            },
+            'id': request_body.get('id')
+        }
+    
+    def handle_unauthenticated_request(self, request_body: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle request with no authentication
+        
+        Args:
+            request_body: JSON-RPC request body
+            
+        Returns:
+            JSON error response requesting authentication
+        """
+        logger.warning("Unauthenticated request received")
+        
+        return {
+            'jsonrpc': '2.0',
+            'error': {
+                'code': -32600,
+                'message': 'Authentication required',
+                'data': {
+                    'supported_methods': [
+                        'Authorization: Bearer <token> (recommended)',
+                        'X-META-APP-ID: Custom Meta app OAuth (advanced users)'
+                    ],
+                    'documentation': 'https://github.com/pipeboard-co/meta-ads-mcp'
+                }
+            },
+            'id': request_body.get('id')
+        }
+
+
 def login_cli():
     """
     Command-line function to authenticate with Meta
@@ -34,17 +203,37 @@ def main():
     """Main entry point for the package"""
     # Log startup information
     logger.info("Meta Ads MCP server starting")
-    logger.info(f"Python version: {sys.version}")
-    logger.info(f"Args: {sys.argv}")
+    logger.debug(f"Python version: {sys.version}")
+    logger.debug(f"Args: {sys.argv}")
     
     # Initialize argument parser
-    parser = argparse.ArgumentParser(description="Meta Ads MCP Server")
+    parser = argparse.ArgumentParser(
+        description="Meta Ads MCP Server - Model Context Protocol server for Meta Ads API",
+        epilog="For more information, see https://github.com/pipeboard-co/meta-ads-mcp"
+    )
     parser.add_argument("--login", action="store_true", help="Authenticate with Meta and store the token")
     parser.add_argument("--app-id", type=str, help="Meta App ID (Client ID) for authentication")
     parser.add_argument("--version", action="store_true", help="Show the version of the package")
     
+    # Transport configuration arguments
+    parser.add_argument("--transport", type=str, choices=["stdio", "streamable-http"], 
+                       default="stdio", 
+                       help="Transport method: 'stdio' for MCP clients (default), 'streamable-http' for HTTP API access")
+    parser.add_argument("--port", type=int, default=8080, 
+                       help="Port for Streamable HTTP transport (default: 8080, only used with --transport streamable-http)")
+    parser.add_argument("--host", type=str, default="localhost", 
+                       help="Host for Streamable HTTP transport (default: localhost, only used with --transport streamable-http)")
+    parser.add_argument("--sse-response", action="store_true", 
+                       help="Use SSE response format instead of JSON (default: JSON, only used with --transport streamable-http)")
+    
     args = parser.parse_args()
-    logger.info(f"Parsed args: login={args.login}, app_id={args.app_id}, version={args.version}")
+    logger.debug(f"Parsed args: login={args.login}, app_id={args.app_id}, version={args.version}")
+    logger.debug(f"Transport args: transport={args.transport}, port={args.port}, host={args.host}, sse_response={args.sse_response}")
+    
+    # Validate CLI argument combinations
+    if args.transport == "stdio" and (args.port != 8080 or args.host != "localhost" or args.sse_response):
+        logger.warning("HTTP transport arguments (--port, --host, --sse-response) are ignored when using stdio transport")
+        print("Warning: HTTP transport arguments are ignored when using stdio transport")
     
     # Update app ID if provided as environment variable or command line arg
     from .auth import auth_manager, meta_config
@@ -52,7 +241,7 @@ def main():
     # Check environment variable first (early init)
     env_app_id = os.environ.get("META_APP_ID")
     if env_app_id:
-        logger.info(f"Found META_APP_ID in environment: {env_app_id}")
+        logger.debug(f"Found META_APP_ID in environment: {env_app_id}")
     else:
         logger.warning("META_APP_ID not found in environment variables")
     
@@ -124,6 +313,69 @@ def main():
                 logger.error(f"Error initiating browser-based authentication: {e}")
                 print(f"Error: Could not start authentication: {e}")
     
-    # Initialize and run the server
-    logger.info("Starting MCP server with stdio transport")
-    mcp_server.run(transport='stdio') 
+    # Transport-specific server initialization and startup
+    if args.transport == "streamable-http":
+        logger.info(f"Starting MCP server with Streamable HTTP transport on {args.host}:{args.port}")
+        logger.info("Mode: Stateless (no session persistence)")
+        logger.info(f"Response format: {'SSE' if args.sse_response else 'JSON'}")
+        logger.info("Primary auth method: Bearer Token (recommended)")
+        logger.info("Fallback auth method: Custom Meta App OAuth (complex setup)")
+        
+        print(f"Starting Meta Ads MCP server with Streamable HTTP transport")
+        print(f"Server will listen on {args.host}:{args.port}")
+        print(f"Response format: {'SSE' if args.sse_response else 'JSON'}")
+        print("Primary authentication: Bearer Token (via Authorization: Bearer <token> header)")
+        print("Fallback authentication: Custom Meta App OAuth (via X-META-APP-ID header)")
+        
+        # Configure the existing server with streamable HTTP settings
+        mcp_server.settings.host = args.host
+        mcp_server.settings.port = args.port
+        mcp_server.settings.stateless_http = True
+        mcp_server.settings.json_response = not args.sse_response
+        
+        # Import all tool modules to ensure they are registered
+        logger.info("Ensuring all tools are registered for HTTP transport")
+        from . import accounts, campaigns, adsets, ads, insights, authentication
+        from . import ads_library, budget_schedules
+        
+        # ✅ NEW: Setup HTTP authentication middleware
+        logger.info("Setting up HTTP authentication middleware")
+        try:
+            from .http_auth_integration import setup_fastmcp_http_auth
+            
+            # Setup the FastMCP HTTP auth integration
+            setup_fastmcp_http_auth(mcp_server)
+            logger.info("FastMCP HTTP authentication integration setup successful")
+            print("✅ FastMCP HTTP authentication integration enabled")
+            print("   - Bearer tokens via Authorization: Bearer <token> header")
+            print("   - Direct Meta tokens via X-META-ACCESS-TOKEN header")
+            
+        except Exception as e:
+            logger.error(f"Failed to setup FastMCP HTTP authentication integration: {e}")
+            print(f"⚠️  FastMCP HTTP authentication integration setup failed: {e}")
+            print("   Server will still start but may not support header-based auth")
+        
+        # Log final server configuration
+        logger.info(f"FastMCP server configured with:")
+        logger.info(f"  - Host: {mcp_server.settings.host}")
+        logger.info(f"  - Port: {mcp_server.settings.port}")
+        logger.info(f"  - Stateless HTTP: {mcp_server.settings.stateless_http}")
+        logger.info(f"  - JSON Response: {mcp_server.settings.json_response}")
+        logger.info(f"  - Streamable HTTP Path: {mcp_server.settings.streamable_http_path}")
+        
+        # Start the FastMCP server with Streamable HTTP transport
+        try:
+            logger.info("Starting FastMCP server with Streamable HTTP transport")
+            print(f"✅ Server configured successfully")
+            print(f"   URL: http://{args.host}:{args.port}{mcp_server.settings.streamable_http_path}/")
+            print(f"   Mode: {'Stateless' if mcp_server.settings.stateless_http else 'Stateful'}")
+            print(f"   Format: {'JSON' if mcp_server.settings.json_response else 'SSE'}")
+            mcp_server.run(transport="streamable-http")
+        except Exception as e:
+            logger.error(f"Error starting Streamable HTTP server: {e}")
+            print(f"Error: Failed to start Streamable HTTP server: {e}")
+            return 1
+    else:
+        # Default stdio transport
+        logger.info("Starting MCP server with stdio transport")
+        mcp_server.run(transport='stdio') 

meta_ads_mcp/core/utils.py

@@ -24,9 +24,13 @@ using_pipeboard = bool(os.environ.get("PIPEBOARD_API_TOKEN", ""))
 # Print warning if Meta app credentials are not configured and not using Pipeboard
 if not using_pipeboard:
     if not META_APP_ID:
-        print("WARNING: META_APP_ID environment variable is not set. Authentication will not work properly.")
+        print("WARNING: META_APP_ID environment variable is not set.")
+        print("RECOMMENDED: Use Pipeboard authentication by setting PIPEBOARD_API_TOKEN instead.")
+        print("ALTERNATIVE: For direct Meta authentication, set META_APP_ID to your Meta App ID.")
     if not META_APP_SECRET:
-        print("WARNING: META_APP_SECRET environment variable is not set. Long-lived token exchange will not work.")
+        print("WARNING: META_APP_SECRET environment variable is not set.")
+        print("NOTE: This is only needed for direct Meta authentication. Pipeboard authentication doesn't require this.")
+        print("RECOMMENDED: Use Pipeboard authentication by setting PIPEBOARD_API_TOKEN instead.")
 
 # Configure logging to file
 def setup_logging():