meta-ads-mcp 0.2.5__py3-none-any.whl → 0.2.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.2.5"
+__version__ = "0.2.8"
 
 __all__ = [
     'get_ad_accounts',
@@ -22,6 +22,7 @@ __all__ = [
     'get_ad_details',
     'get_ad_creatives',
     'get_ad_image',
+    'update_ad',
     'get_insights',
     'debug_image_download',
     'get_login_link',
@@ -43,6 +44,7 @@ from .core import (
     get_ad_details,
     get_ad_creatives,
     get_ad_image,
+    update_ad,
     get_insights,
     debug_image_download,
     get_login_link,

meta_ads_mcp/api.py

@@ -30,7 +30,7 @@ USER_AGENT = "meta-ads-mcp/1.0"
 META_APP_ID = os.environ.get("META_APP_ID", "")  # Default to empty string
 
 # Auth constants
-AUTH_SCOPE = "ads_management,ads_read,business_management"
+AUTH_SCOPE = "ads_management,ads_read,business_management,public_profile"
 AUTH_REDIRECT_URI = "http://localhost:8888/callback"
 AUTH_RESPONSE_TYPE = "token"
 
@@ -521,45 +521,40 @@ def meta_api_tool(func):
         if not access_token:
             needs_authentication = True
             
-            # Start the callback server
-            port = start_callback_server()
+            # Check if we're using Pipeboard authentication
+            using_pipeboard = bool(os.environ.get("PIPEBOARD_API_TOKEN", ""))
             
-            # Get current app ID from config
-            current_app_id = meta_config.get_app_id()
-            if not current_app_id:
-                return json.dumps({
-                    "error": "No Meta App ID provided. Please provide a valid app ID via environment variable META_APP_ID or --app-id CLI argument.",
-                    "help": "This is required for authentication with Meta Graph API."
-                }, indent=2)
-                
-            # Update auth manager with current app ID
-            auth_manager.app_id = current_app_id
-            print(f"Using Meta App ID from config: {current_app_id}")
-            
-            # Update auth manager's redirect URI with the current port
-            auth_manager.redirect_uri = f"http://localhost:{port}/callback"
-            
-            # Generate the authentication URL
-            login_url = auth_manager.get_auth_url()
-            
-            # Return a user-friendly authentication required response
-            return json.dumps({
-                "error": "Authentication Required",
-                "details": {
-                    "message": "You need to authenticate with the Meta API before using this tool",
-                    "action_required": "Please authenticate using the link below",
-                    "login_url": login_url,
-                    "markdown_link": f"[Click here to authenticate with Meta Ads API]({login_url})"
-                }
-            }, indent=2)
-        
-        # Call the original function
-        try:
-            result = await func(**kwargs)
-            
-            # If authentication is needed after the call (e.g., token was invalidated)
-            if needs_authentication:
-                # Start the callback server
+            if using_pipeboard:
+                # For Pipeboard, we use a different authentication flow
+                try:
+                    # Here we'd import dynamically to avoid circular imports
+                    from .core.pipeboard_auth import pipeboard_auth_manager
+                    
+                    # Initiate the Pipeboard auth flow
+                    auth_data = pipeboard_auth_manager.initiate_auth_flow()
+                    login_url = auth_data.get("loginUrl")
+                    
+                    # Return a user-friendly authentication required response for Pipeboard
+                    return json.dumps({
+                        "error": "Authentication Required",
+                        "details": {
+                            "message": "You need to authenticate with the Meta API via Pipeboard",
+                            "action_required": "Please authenticate using the link below",
+                            "login_url": login_url,
+                            "markdown_link": f"[Click here to authenticate with Meta Ads API via Pipeboard]({login_url})",
+                            "authentication_method": "pipeboard"
+                        }
+                    }, indent=2)
+                except Exception as e:
+                    return json.dumps({
+                        "error": f"Pipeboard Authentication Error: {str(e)}",
+                        "details": {
+                            "message": "Failed to initiate Pipeboard authentication flow",
+                            "action_required": "Please check your PIPEBOARD_API_TOKEN environment variable"
+                        }
+                    }, indent=2)
+            else:
+                # For direct Meta auth, start the callback server
                 port = start_callback_server()
                 
                 # Get current app ID from config
@@ -570,6 +565,7 @@ def meta_api_tool(func):
                         "help": "This is required for authentication with Meta Graph API."
                     }, indent=2)
                     
+                # Update auth manager with current app ID
                 auth_manager.app_id = current_app_id
                 print(f"Using Meta App ID from config: {current_app_id}")
                 
@@ -579,21 +575,94 @@ def meta_api_tool(func):
                 # Generate the authentication URL
                 login_url = auth_manager.get_auth_url()
                 
-                # Create a resource response that includes the markdown link format
-                response = {
-                    "error": "Session expired or token invalid. Please re-authenticate with Meta Ads API",
-                    "login_url": login_url,
-                    "server_status": f"Callback server running on port {port}",
-                    "markdown_link": f"[Click here to re-authenticate with Meta Ads API]({login_url})",
-                    "message": "IMPORTANT: Please use the Markdown link format in your response to allow the user to click it.",
-                    "instructions_for_llm": "You must present this link as clickable Markdown to the user using the markdown_link format provided.",
-                    "note": "After authenticating, the token will be automatically saved."
-                }
-                
-                # Wait a moment to ensure the server is fully started
-                await asyncio.sleep(1)
+                # Return a user-friendly authentication required response
+                return json.dumps({
+                    "error": "Authentication Required",
+                    "details": {
+                        "message": "You need to authenticate with the Meta API before using this tool",
+                        "action_required": "Please authenticate using the link below",
+                        "login_url": login_url,
+                        "markdown_link": f"[Click here to authenticate with Meta Ads API]({login_url})",
+                        "authentication_method": "meta_oauth"
+                    }
+                }, indent=2)
+        
+        # Call the original function
+        try:
+            result = await func(**kwargs)
+            
+            # If authentication is needed after the call (e.g., token was invalidated)
+            if needs_authentication:
+                # Check if we're using Pipeboard authentication
+                using_pipeboard = bool(os.environ.get("PIPEBOARD_API_TOKEN", ""))
                 
-                return json.dumps(response, indent=2)
+                if using_pipeboard:
+                    # For Pipeboard, we use a different authentication flow
+                    try:
+                        # Here we'd import dynamically to avoid circular imports
+                        from .core.pipeboard_auth import pipeboard_auth_manager
+                        
+                        # Initiate the Pipeboard auth flow
+                        auth_data = pipeboard_auth_manager.initiate_auth_flow()
+                        login_url = auth_data.get("loginUrl")
+                        
+                        # Create a resource response that includes the markdown link format
+                        response = {
+                            "error": "Session expired or token invalid. Please re-authenticate with Meta Ads API",
+                            "login_url": login_url,
+                            "markdown_link": f"[Click here to re-authenticate with Meta Ads API via Pipeboard]({login_url})",
+                            "message": "IMPORTANT: Please use the Markdown link format in your response to allow the user to click it.",
+                            "instructions_for_llm": "You must present this link as clickable Markdown to the user using the markdown_link format provided.",
+                            "authentication_method": "pipeboard",
+                            "note": "After authenticating, the token will be automatically saved."
+                        }
+                        
+                        return json.dumps(response, indent=2)
+                    except Exception as e:
+                        return json.dumps({
+                            "error": f"Pipeboard Authentication Error: {str(e)}",
+                            "details": {
+                                "message": "Failed to initiate Pipeboard authentication flow",
+                                "action_required": "Please check your PIPEBOARD_API_TOKEN environment variable"
+                            }
+                        }, indent=2)
+                else:
+                    # For direct Meta auth, start the callback server
+                    port = start_callback_server()
+                    
+                    # Get current app ID from config
+                    current_app_id = meta_config.get_app_id()
+                    if not current_app_id:
+                        return json.dumps({
+                            "error": "No Meta App ID provided. Please provide a valid app ID via environment variable META_APP_ID or --app-id CLI argument.",
+                            "help": "This is required for authentication with Meta Graph API."
+                        }, indent=2)
+                        
+                    auth_manager.app_id = current_app_id
+                    print(f"Using Meta App ID from config: {current_app_id}")
+                    
+                    # Update auth manager's redirect URI with the current port
+                    auth_manager.redirect_uri = f"http://localhost:{port}/callback"
+                    
+                    # Generate the authentication URL
+                    login_url = auth_manager.get_auth_url()
+                    
+                    # Create a resource response that includes the markdown link format
+                    response = {
+                        "error": "Session expired or token invalid. Please re-authenticate with Meta Ads API",
+                        "login_url": login_url,
+                        "server_status": f"Callback server running on port {port}",
+                        "markdown_link": f"[Click here to re-authenticate with Meta Ads API]({login_url})",
+                        "message": "IMPORTANT: Please use the Markdown link format in your response to allow the user to click it.",
+                        "instructions_for_llm": "You must present this link as clickable Markdown to the user using the markdown_link format provided.",
+                        "authentication_method": "meta_oauth",
+                        "note": "After authenticating, the token will be automatically saved."
+                    }
+                    
+                    # Wait a moment to ensure the server is fully started
+                    await asyncio.sleep(1)
+                    
+                    return json.dumps(response, indent=2)
             
             # If result is a string (JSON), check for app ID errors and improve them
             if isinstance(result, str):

meta_ads_mcp/core/__init__.py

@@ -4,7 +4,7 @@ from .server import mcp_server
 from .accounts import get_ad_accounts, get_account_info
 from .campaigns import get_campaigns, get_campaign_details, create_campaign
 from .adsets import get_adsets, get_adset_details, update_adset
-from .ads import get_ads, get_ad_details, get_ad_creatives, get_ad_image
+from .ads import get_ads, get_ad_details, get_ad_creatives, get_ad_image, update_ad
 from .insights import get_insights, debug_image_download
 from .authentication import get_login_link
 from .server import login_cli, main
@@ -24,6 +24,7 @@ __all__ = [
     'get_ad_details',
     'get_ad_creatives',
     'get_ad_image',
+    'update_ad',
     'get_insights',
     'debug_image_download',
     'get_login_link',

meta_ads_mcp/core/ads.py

@@ -363,4 +363,64 @@ async def get_ad_image(access_token: str = None, ad_id: str = None) -> Image:
         return Image(data=img_bytes, format="jpeg")
         
     except Exception as e:
-        return f"Error processing image: {str(e)}" 
+        return f"Error processing image: {str(e)}"
+
+
+@mcp_server.tool()
+@meta_api_tool
+async def update_ad(ad_id: str, status: str = None, bid_amount: int = None, access_token: str = None) -> str:
+    """
+    Update an ad with new settings.
+    
+    Args:
+        ad_id: Meta Ads ad ID
+        status: Update ad status (ACTIVE, PAUSED, etc.)
+        bid_amount: Bid amount in account currency (in cents for USD)
+        access_token: Meta API access token (optional - will use cached token if not provided)
+    """
+    if not ad_id:
+        return json.dumps({"error": "No ad ID provided"}, indent=2)
+    
+    changes = {}
+    
+    if status is not None:
+        changes['status'] = status
+        
+    if bid_amount is not None:
+        changes['bid_amount'] = bid_amount
+    
+    if not changes:
+        return json.dumps({"error": "No update parameters provided"}, indent=2)
+    
+    # Get current ad details for comparison
+    current_details_json = await get_ad_details(ad_id=ad_id, access_token=access_token)
+    current_details = json.loads(current_details_json)
+    
+    # Import the callback server components
+    from .callback_server import start_callback_server, update_confirmation
+    import urllib.parse
+    
+    # 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?ad_id={ad_id}&token={access_token}&changes={encoded_changes}"
+    
+    # Reset the update confirmation
+    update_confirmation.clear()
+    update_confirmation.update({"approved": False})
+    
+    # Return the confirmation link
+    response = {
+        "message": "Please confirm the ad update",
+        "confirmation_url": confirmation_url,
+        "markdown_link": f"[Click here to confirm ad update]({confirmation_url})",
+        "current_details": current_details,
+        "proposed_changes": changes,
+        "instructions_for_llm": "You must present this link as clickable Markdown to the user using the markdown_link format provided.",
+        "note": "After authenticating, the token will be automatically saved and your ad will be updated. Refresh the browser page if it doesn't load immediately."
+    }
+    
+    return json.dumps(response, indent=2) 

meta_ads_mcp/core/adsets.py

@@ -6,7 +6,7 @@ from .api import meta_api_tool, make_api_request
 from .accounts import get_ad_accounts
 from .server import mcp_server
 import asyncio
-from .auth import start_callback_server, update_confirmation
+from .callback_server import start_callback_server, update_confirmation
 import urllib.parse
 
 
@@ -78,7 +78,8 @@ async def get_adset_details(access_token: str = None, adset_id: str = None) -> s
 @mcp_server.tool()
 @meta_api_tool
 async def update_adset(adset_id: str, frequency_control_specs: List[Dict[str, Any]] = None, bid_strategy: str = None, 
-                        bid_amount: int = None, status: str = None, targeting: Dict[str, Any] = None, access_token: str = None) -> str:
+                        bid_amount: int = None, status: str = None, targeting: Dict[str, Any] = None, 
+                        optimization_goal: str = None, access_token: str = None) -> str:
     """
     Update an ad set with new settings including frequency caps.
     
@@ -91,6 +92,7 @@ async def update_adset(adset_id: str, frequency_control_specs: List[Dict[str, An
         status: Update ad set status (ACTIVE, PAUSED, etc.)
         targeting: Targeting specifications including targeting_automation
                   (e.g. {"targeting_automation":{"advantage_audience":1}})
+        optimization_goal: Conversion optimization goal (e.g., 'LINK_CLICKS', 'CONVERSIONS', 'APP_INSTALLS', etc.)
         access_token: Meta API access token (optional - will use cached token if not provided)
     """
     if not adset_id:
@@ -110,6 +112,9 @@ async def update_adset(adset_id: str, frequency_control_specs: List[Dict[str, An
     if status is not None:
         changes['status'] = status
         
+    if optimization_goal is not None:
+        changes['optimization_goal'] = optimization_goal
+        
     if targeting is not None:
         # Get current ad set details to preserve existing targeting settings
         current_details_json = await get_adset_details(adset_id=adset_id, access_token=access_token)
@@ -163,7 +168,7 @@ async def update_adset(adset_id: str, frequency_control_specs: List[Dict[str, An
         "current_details": current_details,
         "proposed_changes": changes,
         "instructions_for_llm": "You must present this link as clickable Markdown to the user using the markdown_link format provided.",
-        "note": "After authenticating, the token will be automatically saved and your ad set will be updated. Refresh the browser page if it doesn't load immediately."
+        "note": "Click the link to confirm and apply your ad set updates. Refresh the browser page if it doesn't load immediately."
     }
     
     return json.dumps(response, indent=2) 

meta_ads_mcp/core/api.py

@@ -193,7 +193,7 @@ def meta_api_tool(func):
             logger.debug(f"Current app_id: {app_id}")
             logger.debug(f"META_APP_ID env var: {os.environ.get('META_APP_ID')}")
             
-            # If access_token is not in kwargs, try to get it from auth_manager
+            # If access_token is not in kwargs or not kwargs['access_token'], try to get it from auth_manager
             if 'access_token' not in kwargs or not kwargs['access_token']:
                 try:
                     access_token = await get_current_access_token()
@@ -202,13 +202,36 @@ def meta_api_tool(func):
                         logger.debug("Using access token from auth_manager")
                     else:
                         logger.warning("No access token available from auth_manager")
+                        # Add more details about why token might be missing
+                        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")
+                        else:
+                            logger.error("Check logs above for detailed token validation failures")
                 except Exception as e:
                     logger.error(f"Error getting access token: {str(e)}")
+                    # Add stack trace for better debugging
+                    import traceback
+                    logger.error(f"Stack trace: {traceback.format_exc()}")
             
             # Final validation - if we still don't have a valid token, return authentication required
             if 'access_token' not in kwargs or not kwargs['access_token']:
                 logger.warning("No access token available, authentication needed")
+                
+                # Add more specific troubleshooting information
                 auth_url = auth_manager.get_auth_url()
+                app_id = auth_manager.app_id
+                
+                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'}")
+                
+                # Check for common configuration issues
+                if 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")
+                
                 return json.dumps({
                     "error": {
                         "message": "Authentication Required",
@@ -216,6 +239,11 @@ def meta_api_tool(func):
                             "description": "You need to authenticate with the Meta API before using this tool",
                             "action_required": "Please authenticate first",
                             "auth_url": auth_url,
+                            "configuration_status": {
+                                "app_id_configured": bool(app_id) and app_id != "YOUR_META_APP_ID",
+                                "pipeboard_enabled": bool(os.environ.get('PIPEBOARD_API_TOKEN')),
+                            },
+                            "troubleshooting": "Check logs for TOKEN VALIDATION FAILED messages",
                             "markdown_link": f"[Click here to authenticate with Meta Ads API]({auth_url})"
                         }
                     }