meta-ads-mcp 0.4.0__py3-none-any.whl → 0.4.2__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.4.0"
+__version__ = "0.4.2"
 
 __all__ = [
     'get_ad_accounts',

meta_ads_mcp/core/__init__.py

@@ -12,6 +12,7 @@ from .auth import login
 from .ads_library import search_ads_archive
 from .budget_schedules import create_budget_schedule
 from . import reports  # Import module to register conditional tools
+from . import duplication  # Import module to register conditional duplication tools
 
 __all__ = [
     'mcp_server',

meta_ads_mcp/core/adsets.py

@@ -270,12 +270,21 @@ async def update_adset(adset_id: str, frequency_control_specs: List[Dict[str, An
     current_details = json.loads(current_details_json)
     
     # Start the callback server if not already running
-    port = start_callback_server()
-    
-    # Generate confirmation URL with properly encoded parameters
-    changes_json = json.dumps(changes)
-    encoded_changes = urllib.parse.quote(changes_json)
-    confirmation_url = f"http://localhost:{port}/confirm-update?adset_id={adset_id}&token={access_token}&changes={encoded_changes}"
+    try:
+        port = start_callback_server()
+        
+        # Generate confirmation URL with properly encoded parameters
+        changes_json = json.dumps(changes)
+        encoded_changes = urllib.parse.quote(changes_json)
+        confirmation_url = f"http://localhost:{port}/confirm-update?adset_id={adset_id}&token={access_token}&changes={encoded_changes}"
+    except Exception as e:
+        return json.dumps({
+            "error": "Callback server disabled",
+            "message": f"Cannot create confirmation URL: {str(e)}",
+            "suggestion": "Manual update confirmation not available when META_ADS_DISABLE_CALLBACK_SERVER is set",
+            "adset_id": adset_id,
+            "proposed_changes": changes
+        }, indent=2)
     
     # Reset the update confirmation
     update_confirmation.clear()

meta_ads_mcp/core/auth.py

@@ -216,22 +216,27 @@ class AuthManager:
             return self.token_info.access_token
         
         # Start the callback server if not already running
-        port = start_callback_server()
-        
-        # Update redirect URI with the actual port
-        self.redirect_uri = f"http://localhost:{port}/callback"
-        
-        # Generate the auth URL
-        auth_url = self.get_auth_url()
-        
-        # Open browser with auth URL
-        logger.info(f"Opening browser with URL: {auth_url}")
-        webbrowser.open(auth_url)
-        
-        # We don't wait for the token here anymore
-        # The token will be processed by the callback server
-        # Just return None to indicate we've started the flow
-        return None
+        try:
+            port = start_callback_server()
+            
+            # Update redirect URI with the actual port
+            self.redirect_uri = f"http://localhost:{port}/callback"
+            
+            # Generate the auth URL
+            auth_url = self.get_auth_url()
+            
+            # Open browser with auth URL
+            logger.info(f"Opening browser with URL: {auth_url}")
+            webbrowser.open(auth_url)
+            
+            # We don't wait for the token here anymore
+            # The token will be processed by the callback server
+            # Just return None to indicate we've started the flow
+            return None
+        except Exception as e:
+            logger.error(f"Failed to start callback server: {e}")
+            logger.info("Callback server disabled. OAuth authentication flow cannot be used.")
+            return None
     
     def get_access_token(self) -> Optional[str]:
         """
@@ -477,7 +482,14 @@ def login():
     
     try:
         # Start the callback server first
-        port = start_callback_server()
+        try:
+            port = start_callback_server()
+        except Exception as callback_error:
+            print(f"Error: {callback_error}")
+            print("Callback server is disabled. Please use alternative authentication methods:")
+            print("- Set PIPEBOARD_API_TOKEN environment variable for Pipeboard authentication")
+            print("- Or provide a direct META_ACCESS_TOKEN environment variable")
+            return
         
         # Get the auth URL and open the browser
         auth_url = auth_manager.get_auth_url()

meta_ads_mcp/core/authentication.py

@@ -90,14 +90,23 @@ async def get_login_link(access_token: str = None) -> str:
         # IMPORTANT: Start the callback server first by calling our helper function
         # This ensures the server is ready before we provide the URL to the user
         logger.info("Starting callback server for authentication")
-        port = start_callback_server()
-        logger.info(f"Callback server started on port {port}")
-        
-        # Generate direct login URL
-        auth_manager.redirect_uri = f"http://localhost:{port}/callback"  # Ensure port is set correctly
-        logger.info(f"Setting redirect URI to {auth_manager.redirect_uri}")
-        login_url = auth_manager.get_auth_url()
-        logger.info(f"Generated login URL: {login_url}")
+        try:
+            port = start_callback_server()
+            logger.info(f"Callback server started on port {port}")
+            
+            # Generate direct login URL
+            auth_manager.redirect_uri = f"http://localhost:{port}/callback"  # Ensure port is set correctly
+            logger.info(f"Setting redirect URI to {auth_manager.redirect_uri}")
+            login_url = auth_manager.get_auth_url()
+            logger.info(f"Generated login URL: {login_url}")
+        except Exception as e:
+            logger.error(f"Failed to start callback server: {e}")
+            return json.dumps({
+                "error": "Callback server disabled",
+                "message": str(e),
+                "suggestion": "Use Pipeboard authentication (set PIPEBOARD_API_TOKEN) or provide a direct access token",
+                "authentication_method": "meta_oauth_disabled"
+            }, indent=2)
         
         # Check if we can exchange for long-lived tokens
         token_exchange_supported = bool(META_APP_SECRET)

meta_ads_mcp/core/callback_server.py

@@ -917,7 +917,16 @@ def start_callback_server() -> int:
     
     Returns:
         Port number the server is running on
+    
+    Raises:
+        Exception: If callback server is disabled via META_ADS_DISABLE_CALLBACK_SERVER environment variable
     """
+    # Check if callback server is disabled via environment variable
+    if os.environ.get("META_ADS_DISABLE_CALLBACK_SERVER"):
+        logger.info("Callback server disabled via META_ADS_DISABLE_CALLBACK_SERVER environment variable")
+        print("Callback server is disabled. OAuth authentication flow cannot be used.")
+        raise Exception("Callback server disabled via META_ADS_DISABLE_CALLBACK_SERVER environment variable. Use alternative authentication methods.")
+    
     global callback_server_thread, callback_server_running, callback_server_port, callback_server_instance, server_shutdown_timer
     
     with callback_server_lock:

meta_ads_mcp/core/duplication.py

@@ -0,0 +1,443 @@
+"""Duplication functionality for Meta Ads API."""
+
+import json
+import os
+import httpx
+from typing import Optional, Dict, Any, List, Union
+from .server import mcp_server
+from .api import meta_api_tool
+from .auth import get_current_access_token
+from .http_auth_integration import FastMCPAuthIntegration
+
+
+# Only register the duplication functions if the environment variable is set
+ENABLE_DUPLICATION = bool(os.environ.get("META_ADS_ENABLE_DUPLICATION", ""))
+
+if ENABLE_DUPLICATION:
+    @mcp_server.tool()
+    @meta_api_tool
+    async def duplicate_campaign(
+        campaign_id: str,
+        access_token: str = None,
+        name_suffix: Optional[str] = " - Copy",
+        include_ad_sets: bool = True,
+        include_ads: bool = True,
+        include_creatives: bool = True,
+        copy_schedule: bool = False,
+        new_daily_budget: Optional[float] = None,
+        new_status: Optional[str] = "PAUSED"
+    ) -> str:
+        """
+        Duplicate a Meta Ads campaign with all its ad sets and ads.
+
+        **SUBSCRIPTION REQUIRED**: This feature requires an active subscription.
+        
+        Args:
+            campaign_id: Meta Ads campaign ID to duplicate
+            name_suffix: Suffix to add to the duplicated campaign name
+            include_ad_sets: Whether to duplicate ad sets within the campaign
+            include_ads: Whether to duplicate ads within ad sets
+            include_creatives: Whether to duplicate ad creatives
+            copy_schedule: Whether to copy the campaign schedule
+            new_daily_budget: Override the daily budget for the new campaign
+            new_status: Status for the new campaign (ACTIVE or PAUSED)
+        """
+        return await _forward_duplication_request(
+            "campaign",
+            campaign_id,
+            access_token,
+            {
+                "name_suffix": name_suffix,
+                "include_ad_sets": include_ad_sets,
+                "include_ads": include_ads,
+                "include_creatives": include_creatives,
+                "copy_schedule": copy_schedule,
+                "new_daily_budget": new_daily_budget,
+                "new_status": new_status
+            }
+        )
+
+    @mcp_server.tool()
+    @meta_api_tool
+    async def duplicate_adset(
+        adset_id: str,
+        access_token: str = None,
+        target_campaign_id: Optional[str] = None,
+        name_suffix: Optional[str] = " - Copy",
+        include_ads: bool = True,
+        include_creatives: bool = True,
+        new_daily_budget: Optional[float] = None,
+        new_targeting: Optional[Dict[str, Any]] = None,
+        new_status: Optional[str] = "PAUSED"
+    ) -> str:
+        """
+        Duplicate a Meta Ads ad set with its ads.
+
+        **SUBSCRIPTION REQUIRED**: This feature requires an active subscription.
+        
+        Args:
+            adset_id: Meta Ads ad set ID to duplicate
+            target_campaign_id: Campaign ID to move the duplicated ad set to (optional)
+            name_suffix: Suffix to add to the duplicated ad set name
+            include_ads: Whether to duplicate ads within the ad set
+            include_creatives: Whether to duplicate ad creatives
+            new_daily_budget: Override the daily budget for the new ad set
+            new_targeting: Override targeting settings for the new ad set
+            new_status: Status for the new ad set (ACTIVE or PAUSED)
+        """
+        return await _forward_duplication_request(
+            "adset",
+            adset_id,
+            access_token,
+            {
+                "target_campaign_id": target_campaign_id,
+                "name_suffix": name_suffix,
+                "include_ads": include_ads,
+                "include_creatives": include_creatives,
+                "new_daily_budget": new_daily_budget,
+                "new_targeting": new_targeting,
+                "new_status": new_status
+            }
+        )
+
+    @mcp_server.tool()
+    @meta_api_tool
+    async def duplicate_ad(
+        ad_id: str,
+        access_token: str = None,
+        target_adset_id: Optional[str] = None,
+        name_suffix: Optional[str] = " - Copy",
+        duplicate_creative: bool = True,
+        new_creative_name: Optional[str] = None,
+        new_status: Optional[str] = "PAUSED"
+    ) -> str:
+        """
+        Duplicate a Meta Ads ad.
+
+        **SUBSCRIPTION REQUIRED**: This feature requires an active subscription.
+        
+        Args:
+            ad_id: Meta Ads ad ID to duplicate
+            target_adset_id: Ad set ID to move the duplicated ad to (optional)
+            name_suffix: Suffix to add to the duplicated ad name
+            duplicate_creative: Whether to duplicate the ad creative
+            new_creative_name: Override name for the duplicated creative
+            new_status: Status for the new ad (ACTIVE or PAUSED)
+        """
+        return await _forward_duplication_request(
+            "ad",
+            ad_id,
+            access_token,
+            {
+                "target_adset_id": target_adset_id,
+                "name_suffix": name_suffix,
+                "duplicate_creative": duplicate_creative,
+                "new_creative_name": new_creative_name,
+                "new_status": new_status
+            }
+        )
+
+    @mcp_server.tool()
+    @meta_api_tool
+    async def duplicate_creative(
+        creative_id: str,
+        access_token: str = None,
+        name_suffix: Optional[str] = " - Copy",
+        new_primary_text: Optional[str] = None,
+        new_headline: Optional[str] = None,
+        new_description: Optional[str] = None,
+        new_cta_type: Optional[str] = None,
+        new_destination_url: Optional[str] = None
+    ) -> str:
+        """
+        Duplicate a Meta Ads creative.
+
+        **SUBSCRIPTION REQUIRED**: This feature requires an active subscription.
+        
+        Args:
+            creative_id: Meta Ads creative ID to duplicate
+            name_suffix: Suffix to add to the duplicated creative name
+            new_primary_text: Override the primary text for the new creative
+            new_headline: Override the headline for the new creative
+            new_description: Override the description for the new creative
+            new_cta_type: Override the call-to-action type for the new creative
+            new_destination_url: Override the destination URL for the new creative
+        """
+        return await _forward_duplication_request(
+            "creative",
+            creative_id,
+            access_token,
+            {
+                "name_suffix": name_suffix,
+                "new_primary_text": new_primary_text,
+                "new_headline": new_headline,
+                "new_description": new_description,
+                "new_cta_type": new_cta_type,
+                "new_destination_url": new_destination_url
+            }
+        )
+
+
+async def _forward_duplication_request(resource_type: str, resource_id: str, access_token: str, options: Dict[str, Any]) -> str:
+    """
+    Forward duplication request to the cloud-hosted MCP API using dual-header authentication.
+    
+    This implements the dual-header authentication pattern for MCP server callbacks:
+    - Authorization: Bearer <facebook_token> - Facebook access token for Meta API calls
+    - X-Pipeboard-Token: <pipeboard_token> - Pipeboard API token for authentication
+    
+    Args:
+        resource_type: Type of resource to duplicate (campaign, adset, ad, creative)
+        resource_id: ID of the resource to duplicate
+        access_token: Meta API access token (optional, will use context if not provided)
+        options: Duplication options
+    """
+    try:
+        # Get tokens from the request context that were set by the HTTP auth middleware
+        # In the dual-header authentication pattern:
+        # - Pipeboard token comes from X-Pipeboard-Token header (for authentication)
+        # - Facebook token comes from Authorization header (for Meta API calls)
+        
+        # Get tokens from context set by AuthInjectionMiddleware
+        pipeboard_token = FastMCPAuthIntegration.get_pipeboard_token()
+        facebook_token = FastMCPAuthIntegration.get_auth_token()
+        
+        # Use provided access_token parameter if no Facebook token found in context
+        if not facebook_token:
+            facebook_token = access_token if access_token else await get_current_access_token()
+        
+        # Validate we have both required tokens
+        if not pipeboard_token:
+            return json.dumps({
+                "error": "authentication_required",
+                "message": "Pipeboard API token not found",
+                "details": {
+                    "required": "Valid Pipeboard token via X-Pipeboard-Token header",
+                    "received_headers": "Check that the MCP server is forwarding the X-Pipeboard-Token header"
+                }
+            }, indent=2)
+            
+        if not facebook_token:
+            return json.dumps({
+                "error": "authentication_required",
+                "message": "Meta Ads access token not found",
+                "details": {
+                    "required": "Valid Meta access token from authenticated session",
+                    "check": "Ensure Facebook account is connected and token is valid"
+                }
+            }, indent=2)
+
+        # Construct the API endpoint
+        base_url = "https://mcp.pipeboard.co"
+        endpoint = f"{base_url}/api/meta/duplicate/{resource_type}/{resource_id}"
+        
+        # Prepare the dual-header authentication as per API documentation
+        headers = {
+            "Authorization": f"Bearer {facebook_token}",  # Facebook token for Meta API
+            "X-Pipeboard-Token": pipeboard_token,         # Pipeboard token for auth
+            "Content-Type": "application/json",
+            "User-Agent": "meta-ads-mcp/1.0"
+        }
+        
+        # Remove None values from options
+        clean_options = {k: v for k, v in options.items() if v is not None}
+        
+        # Make the request to the cloud service
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.post(
+                endpoint,
+                headers=headers,
+                json=clean_options
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                return json.dumps(result, indent=2)
+            elif response.status_code == 400:
+                # Validation failed
+                try:
+                    error_data = response.json()
+                    return json.dumps({
+                        "success": False,
+                        "error": "validation_failed",
+                        "errors": error_data.get("errors", [response.text]),
+                        "warnings": error_data.get("warnings", [])
+                    }, indent=2)
+                except:
+                    return json.dumps({
+                        "success": False,
+                        "error": "validation_failed",
+                        "errors": [response.text],
+                        "warnings": []
+                    }, indent=2)
+            elif response.status_code == 401:
+                return json.dumps({
+                    "success": False,
+                    "error": "authentication_error",
+                    "message": "Invalid or expired API token"
+                }, indent=2)
+            elif response.status_code == 402:
+                try:
+                    error_data = response.json()
+                    return json.dumps({
+                        "success": False,
+                        "error": "subscription_required",
+                        "message": error_data.get("message", "This feature is not available in your current plan"),
+                        "upgrade_url": error_data.get("upgrade_url", "https://pipeboard.co/upgrade"),
+                        "suggestion": error_data.get("suggestion", "Please upgrade your account to access this feature")
+                    }, indent=2)
+                except:
+                    return json.dumps({
+                        "success": False,
+                        "error": "subscription_required",
+                        "message": "This feature is not available in your current plan",
+                        "upgrade_url": "https://pipeboard.co/upgrade",
+                        "suggestion": "Please upgrade your account to access this feature"
+                    }, indent=2)
+            elif response.status_code == 403:
+                try:
+                    error_data = response.json()
+                    # Check if this is a premium feature error
+                    if error_data.get("error") == "premium_feature":
+                        return json.dumps({
+                            "success": False,
+                            "error": "premium_feature_required",
+                            "message": error_data.get("message", "This is a premium feature that requires subscription"),
+                            "details": error_data.get("details", {
+                                "upgrade_url": "https://pipeboard.co/upgrade",
+                                "suggestion": "Please upgrade your account to access this feature"
+                            })
+                        }, indent=2)
+                    else:
+                        # Default to facebook connection required
+                        return json.dumps({
+                            "success": False,
+                            "error": "facebook_connection_required",
+                            "message": error_data.get("message", "You need to connect your Facebook account first"),
+                            "details": error_data.get("details", {
+                                "login_flow_url": "/connections",
+                                "auth_flow_url": "/api/meta/auth"
+                            })
+                        }, indent=2)
+                except:
+                    return json.dumps({
+                        "success": False,
+                        "error": "facebook_connection_required",
+                        "message": "You need to connect your Facebook account first",
+                        "details": {
+                            "login_flow_url": "/connections",
+                            "auth_flow_url": "/api/meta/auth"
+                        }
+                    }, indent=2)
+            elif response.status_code == 404:
+                return json.dumps({
+                    "success": False,
+                    "error": "resource_not_found",
+                    "message": f"{resource_type.title()} not found or access denied",
+                    "suggestion": f"Verify the {resource_type} ID and your Facebook account permissions"
+                }, indent=2)
+            elif response.status_code == 429:
+                return json.dumps({
+                    "error": "rate_limit_exceeded", 
+                    "message": "Meta API rate limit exceeded",
+                    "details": {
+                        "suggestion": "Please wait before retrying",
+                        "retry_after": response.headers.get("Retry-After", "60")
+                    }
+                }, indent=2)
+            elif response.status_code == 502:
+                try:
+                    error_data = response.json()
+                    return json.dumps({
+                        "success": False,
+                        "error": "meta_api_error",
+                        "message": error_data.get("message", "Facebook API error"),
+                        "recoverable": True,
+                        "suggestion": "Please wait 5 minutes before retrying"
+                    }, indent=2)
+                except:
+                    return json.dumps({
+                        "success": False,
+                        "error": "meta_api_error",
+                        "message": "Facebook API error",
+                        "recoverable": True,
+                        "suggestion": "Please wait 5 minutes before retrying"
+                    }, indent=2)
+            else:
+                error_detail = response.text
+                try:
+                    error_json = response.json()
+                    error_detail = error_json.get("message", error_detail)
+                except:
+                    pass
+                
+                return json.dumps({
+                    "error": "duplication_failed",
+                    "message": f"Failed to duplicate {resource_type}",
+                    "details": {
+                        "status_code": response.status_code,
+                        "error_detail": error_detail,
+                        "resource_type": resource_type,
+                        "resource_id": resource_id
+                    }
+                }, indent=2)
+    
+    except httpx.TimeoutException:
+        return json.dumps({
+            "error": "request_timeout",
+            "message": "Request to duplication service timed out",
+            "details": {
+                "suggestion": "Please try again later",
+                "timeout": "30 seconds"
+            }
+        }, indent=2)
+    
+    except httpx.RequestError as e:
+        return json.dumps({
+            "error": "network_error", 
+            "message": "Failed to connect to duplication service",
+            "details": {
+                "error": str(e),
+                "suggestion": "Check your internet connection and try again"
+            }
+        }, indent=2)
+    
+    except Exception as e:
+        return json.dumps({
+            "error": "unexpected_error",
+            "message": f"Unexpected error during {resource_type} duplication",
+            "details": {
+                "error": str(e),
+                "resource_type": resource_type,
+                "resource_id": resource_id
+            }
+        }, indent=2)
+
+
+def _get_estimated_components(resource_type: str, options: Dict[str, Any]) -> Dict[str, Any]:
+    """Get estimated components that would be duplicated."""
+    if resource_type == "campaign":
+        components = {"campaigns": 1}
+        if options.get("include_ad_sets", True):
+            components["ad_sets"] = "3-5 (estimated)"
+        if options.get("include_ads", True):
+            components["ads"] = "5-15 (estimated)"
+        if options.get("include_creatives", True):
+            components["creatives"] = "5-15 (estimated)"
+        return components
+    elif resource_type == "adset":
+        components = {"ad_sets": 1}
+        if options.get("include_ads", True):
+            components["ads"] = "2-5 (estimated)"
+        if options.get("include_creatives", True):
+            components["creatives"] = "2-5 (estimated)"
+        return components
+    elif resource_type == "ad":
+        components = {"ads": 1}
+        if options.get("duplicate_creative", True):
+            components["creatives"] = 1
+        return components
+    elif resource_type == "creative":
+        return {"creatives": 1}
+    
+    return {} 

meta_ads_mcp/core/http_auth_integration.py

@@ -13,6 +13,7 @@ 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)
+_pipeboard_token: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar('pipeboard_token', default=None)
 
 class FastMCPAuthIntegration:
     """Direct integration with FastMCP for HTTP authentication"""
@@ -35,11 +36,34 @@ class FastMCPAuthIntegration:
         """
         return _auth_token.get(None)
     
+    @staticmethod
+    def set_pipeboard_token(token: str) -> None:
+        """Set Pipeboard token for the current context
+        
+        Args:
+            token: Pipeboard API token to use for this request
+        """
+        _pipeboard_token.set(token)
+    
+    @staticmethod
+    def get_pipeboard_token() -> Optional[str]:
+        """Get Pipeboard token for the current context
+        
+        Returns:
+            Pipeboard token if set, None otherwise
+        """
+        return _pipeboard_token.get(None)
+    
     @staticmethod
     def clear_auth_token() -> None:
         """Clear authentication token for the current context"""
         _auth_token.set(None)
     
+    @staticmethod
+    def clear_pipeboard_token() -> None:
+        """Clear Pipeboard token for the current context"""
+        _pipeboard_token.set(None)
+    
     @staticmethod
     def extract_token_from_headers(headers: dict) -> Optional[str]:
         """Extract token from HTTP headers
@@ -69,6 +93,30 @@ class FastMCPAuthIntegration:
             return pipeboard_token
         
         return None
+    
+    @staticmethod
+    def extract_pipeboard_token_from_headers(headers: dict) -> Optional[str]:
+        """Extract Pipeboard token from HTTP headers
+        
+        Args:
+            headers: HTTP request headers
+            
+        Returns:
+            Pipeboard token if found, None otherwise
+        """
+        # Check for Pipeboard token in X-Pipeboard-Token header (duplication API pattern)
+        pipeboard_token = headers.get('X-Pipeboard-Token') or headers.get('x-pipeboard-token')
+        if pipeboard_token:
+            logger.debug("Found Pipeboard token in X-Pipeboard-Token header")
+            return pipeboard_token
+        
+        # Check for legacy Pipeboard token header
+        legacy_token = headers.get('X-PIPEBOARD-API-TOKEN') or headers.get('x-pipeboard-api-token')
+        if legacy_token:
+            logger.debug("Found Pipeboard token in legacy X-PIPEBOARD-API-TOKEN header")
+            return legacy_token
+        
+        return None
 
 def patch_fastmcp_server(mcp_server):
     """Patch FastMCP server to inject authentication from HTTP headers
@@ -203,21 +251,32 @@ class AuthInjectionMiddleware(BaseHTTPMiddleware):
         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))
+        # Extract both types of tokens for dual-header authentication
+        auth_token = FastMCPAuthIntegration.extract_token_from_headers(dict(request.headers))
+        pipeboard_token = FastMCPAuthIntegration.extract_pipeboard_token_from_headers(dict(request.headers))
         
-        if token:
-            logger.debug(f"HTTP Auth Middleware: Extracted token: {token[:10]}...")
+        if auth_token:
+            logger.debug(f"HTTP Auth Middleware: Extracted auth token: {auth_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")
+            FastMCPAuthIntegration.set_auth_token(auth_token)
+        
+        if pipeboard_token:
+            logger.debug(f"HTTP Auth Middleware: Extracted Pipeboard token: {pipeboard_token[:10]}...")
+            logger.debug("Injecting Pipeboard token into request context")
+            FastMCPAuthIntegration.set_pipeboard_token(pipeboard_token)
+        
+        if not auth_token and not pipeboard_token:
+            logger.warning("HTTP Auth Middleware: No authentication tokens found in headers")
         
         try:
             response = await call_next(request)
             return response
         finally:
-            if token: # Clear only if a token was set for this request
+            # Clear tokens that were set for this request
+            if auth_token:
                 FastMCPAuthIntegration.clear_auth_token()
+            if pipeboard_token:
+                FastMCPAuthIntegration.clear_pipeboard_token()
 
 def setup_starlette_middleware(app):
     """Add AuthInjectionMiddleware to the Starlette app if not already present.

{meta_ads_mcp-0.4.0.dist-info → meta_ads_mcp-0.4.2.dist-info}/METADATA

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: meta-ads-mcp
-Version: 0.4.0
-Summary: Model Calling Protocol (MCP) plugin for interacting with Meta Ads API
+Version: 0.4.2
+Summary: Model Context Protocol (MCP) plugin for interacting with Meta Ads API
 Project-URL: Homepage, https://github.com/pipeboard-co/meta-ads-mcp
 Project-URL: Bug Tracker, https://github.com/pipeboard-co/meta-ads-mcp/issues
 Author-email: Yves Junqueira <yves.junqueira@gmail.com>
-License: MIT
+License: Apache-2.0
 License-File: LICENSE
 Keywords: ads,api,claude,facebook,mcp,meta
-Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
@@ -16,6 +16,8 @@ Requires-Dist: httpx>=0.26.0
 Requires-Dist: mcp[cli]>=1.10.1
 Requires-Dist: pathlib>=1.0.1
 Requires-Dist: pillow>=10.0.0
+Requires-Dist: pytest-asyncio>=1.0.0
+Requires-Dist: pytest>=8.4.1
 Requires-Dist: python-dateutil>=2.8.2
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: requests>=2.32.3
@@ -63,17 +65,14 @@ That's it! You can now ask Claude to analyze your Meta ad campaigns, get perform
 
 ### For Cursor Users
 
-Add this to your `~/.cursor/mcp.json`:
+Add the following to your `~/.cursor/mcp.json`. Once you enable the remote MCP, click on "Needs login" to finish the login process.
+
 
 ```json
 {
   "mcpServers": {
     "meta-ads-remote": {
-      "command": "npx",
-      "args": [
-        "mcp-remote",
-        "https://mcp.pipeboard.co/meta-ads-mcp"
-      ]
+      "url": "https://mcp.pipeboard.co/meta-ads-mcp"
     }
   }
 }

{meta_ads_mcp-0.4.0.dist-info → meta_ads_mcp-0.4.2.dist-info}/RECORD

@@ -1,25 +1,26 @@
-meta_ads_mcp/__init__.py,sha256=Ive8lkiVBTI71DtD75td68TiZ597_Br6xiYdVIbJaw0,1182
+meta_ads_mcp/__init__.py,sha256=r7i4rteDOpqUZK4ZZkN5oihxeyUjOIAx-0xIyMqwPkU,1182
 meta_ads_mcp/__main__.py,sha256=XaQt3iXftG_7f0Zu7Wop9SeFgrD2WBn0EQOaPMc27d8,207
-meta_ads_mcp/core/__init__.py,sha256=TQSAEn_c_n5ShXcgPXbzDNfIfiPUgJAGe3VIUvSyvjo,1124
+meta_ads_mcp/core/__init__.py,sha256=XVJjMOfdgnqxy3k8vCn2PCf7za8fMk4BdgJGiSFCVZY,1209
 meta_ads_mcp/core/accounts.py,sha256=Nmp7lPxO9wmq25jWV7_H0LIqnEbBhpCVBlLGW2HUaq0,2277
 meta_ads_mcp/core/ads.py,sha256=b_81GlGHIM4jISvuDZmHNyc6uW7uD3ovX68ezBci9MM,29747
 meta_ads_mcp/core/ads_library.py,sha256=onStn9UkRqYDC60gOPS-iKDtP1plz6DygUb7hUZ0Jw8,2807
-meta_ads_mcp/core/adsets.py,sha256=WBPNaI7ITnUOnGMus4_0MX15DslOCzfM5q1zF1VWs2s,12408
+meta_ads_mcp/core/adsets.py,sha256=8m8RDsa1CmCb75-YXcMHDYNpa8J12ovtQPp0kgYHDk4,12823
 meta_ads_mcp/core/api.py,sha256=aAzM6Q75VQOFXtr5D-mDmBRhxWK4wsiODsJYnR3mpDI,14994
-meta_ads_mcp/core/auth.py,sha256=pDARBh3NBNqCpxflVrVvR4VsWuIveFxQmb9-P-gLFDM,20730
-meta_ads_mcp/core/authentication.py,sha256=PFqmN7ujtNsJCEDutDzs81peGWFJ8_0YLYI3-o8kmt4,6577
+meta_ads_mcp/core/auth.py,sha256=z8HfLbDNB7IzoIcqt-lBGne6P97FF-dubO_cZNe5S_8,21425
+meta_ads_mcp/core/authentication.py,sha256=4CH2Fe3w7Al7YE2wgoa0DW5qOXTp_5Lsa4T6_Rh55s0,7048
 meta_ads_mcp/core/budget_schedules.py,sha256=UxseExsvKAiPwfDCY9aycT4kys4xqeNytyq-yyDOxrs,2901
-meta_ads_mcp/core/callback_server.py,sha256=AUymElaVwHqFyqB2wgqf6A68KsqwtKoYmY-7JZZt8Ks,43286
+meta_ads_mcp/core/callback_server.py,sha256=wNuxmj7YTFeSdVGi_iJ9vberNy3VdzBIP0uSsqn7g5Q,43888
 meta_ads_mcp/core/campaigns.py,sha256=Fd477GsD1Gx08Ve0uXUCvr4fC-xQCeVHPBwRVaeRQKk,10965
-meta_ads_mcp/core/http_auth_integration.py,sha256=ZJHuxK1Kwtr9gvwfC5HZOLH5MW-HnDDKqJc4xuG5yVE,10060
+meta_ads_mcp/core/duplication.py,sha256=UUmTDFx9o5ZsPQG2Rb9c4ZyuKUVN3FfTjebfTIHHdo4,18984
+meta_ads_mcp/core/http_auth_integration.py,sha256=lGpKhfzJcyWugBcYEvypY-qnlt-3UDBLqh7xAUH0DGw,12473
 meta_ads_mcp/core/insights.py,sha256=U7KYdWQpGcdykE1WUtdJdYR3VTwKrXUzIzCREwWbf48,2599
 meta_ads_mcp/core/pipeboard_auth.py,sha256=VvbxEB8ZOhnMccLU7HI1HgaPWHCl5NGrzZCm-zzHze4,22798
 meta_ads_mcp/core/reports.py,sha256=Dv3hfsPOR7IZ9WrYrKd_6SNgZl-USIphg7knva3UYAw,5747
 meta_ads_mcp/core/resources.py,sha256=-zIIfZulpo76vcKv6jhAlQq91cR2SZ3cjYZt3ek3x0w,1236
 meta_ads_mcp/core/server.py,sha256=mmhtcyB7h1aO6jK4njLztPdAebPDmc3mhA7DksR1nlY,17583
 meta_ads_mcp/core/utils.py,sha256=DsizDYuJnWUpkbShV1y5Qe8t47Qf59aPZ6O9v0hzdkY,6705
-meta_ads_mcp-0.4.0.dist-info/METADATA,sha256=qYEgWGno8pVxWx7qV9vK3GZwDsJhhkRTfX6dWaMeZ7M,17125
-meta_ads_mcp-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-meta_ads_mcp-0.4.0.dist-info/entry_points.txt,sha256=Dv2RkoBjRJBqj6CyhwqGIiwPCD-SCL1-7B9-zmVRuv0,57
-meta_ads_mcp-0.4.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-meta_ads_mcp-0.4.0.dist-info/RECORD,,
+meta_ads_mcp-0.4.2.dist-info/METADATA,sha256=M2VY7kNALGcXOYYjvwkxbmp3Ced9m3JO_hzAkjTxEQU,17239
+meta_ads_mcp-0.4.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+meta_ads_mcp-0.4.2.dist-info/entry_points.txt,sha256=Dv2RkoBjRJBqj6CyhwqGIiwPCD-SCL1-7B9-zmVRuv0,57
+meta_ads_mcp-0.4.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+meta_ads_mcp-0.4.2.dist-info/RECORD,,