meta-ads-mcp 0.2.6__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.6"
+__version__ = "0.2.8"
 
 __all__ = [
     'get_ad_accounts',

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/adsets.py

@@ -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})"
                         }
                     }

meta_ads_mcp/core/auth.py

@@ -18,8 +18,11 @@ from .callback_server import (
     update_confirmation
 )
 
+# Import the new Pipeboard authentication
+from .pipeboard_auth import pipeboard_auth_manager
+
 # 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"
 
@@ -123,7 +126,10 @@ class AuthManager:
         self.app_id = app_id
         self.redirect_uri = redirect_uri
         self.token_info = None
-        self._load_cached_token()
+        # Check for Pipeboard token first
+        self.use_pipeboard = bool(os.environ.get("PIPEBOARD_API_TOKEN", ""))
+        if not self.use_pipeboard:
+            self._load_cached_token()
     
     def _get_token_cache_path(self) -> pathlib.Path:
         """Get the platform-specific path for token cache file"""
@@ -154,14 +160,14 @@ class AuthManager:
                 
                 # Check if token is expired
                 if self.token_info.is_expired():
-                    print("Cached token is expired")
+                    logger.info("Cached token is expired")
                     self.token_info = None
                     return False
                 
-                print(f"Loaded cached token (expires in {(self.token_info.created_at + self.token_info.expires_in) - int(time.time())} seconds)")
+                logger.info(f"Loaded cached token (expires in {(self.token_info.created_at + self.token_info.expires_in) - int(time.time())} seconds)")
                 return True
         except Exception as e:
-            print(f"Error loading cached token: {e}")
+            logger.error(f"Error loading cached token: {e}")
             return False
     
     def _save_token_to_cache(self) -> None:
@@ -174,9 +180,9 @@ class AuthManager:
         try:
             with open(cache_path, "w") as f:
                 json.dump(self.token_info.serialize(), f)
-            print(f"Token cached at: {cache_path}")
+            logger.info(f"Token cached at: {cache_path}")
         except Exception as e:
-            print(f"Error saving token to cache: {e}")
+            logger.error(f"Error saving token to cache: {e}")
     
     def get_auth_url(self) -> str:
         """Generate the Facebook OAuth URL for desktop app flow"""
@@ -198,6 +204,12 @@ class AuthManager:
         Returns:
             Access token if successful, None otherwise
         """
+        # If Pipeboard auth is available, use that instead
+        if self.use_pipeboard:
+            logger.info("Using Pipeboard authentication")
+            return pipeboard_auth_manager.get_access_token(force_refresh=force_refresh)
+        
+        # Otherwise, use the original OAuth flow
         # Check if we already have a valid token
         if not force_refresh and self.token_info and not self.token_info.is_expired():
             return self.token_info.access_token
@@ -212,7 +224,7 @@ class AuthManager:
         auth_url = self.get_auth_url()
         
         # Open browser with auth URL
-        print(f"Opening browser with URL: {auth_url}")
+        logger.info(f"Opening browser with URL: {auth_url}")
         webbrowser.open(auth_url)
         
         # We don't wait for the token here anymore
@@ -227,6 +239,10 @@ class AuthManager:
         Returns:
             Access token if available, None otherwise
         """
+        # If using Pipeboard, always delegate to the Pipeboard auth manager
+        if self.use_pipeboard:
+            return pipeboard_auth_manager.get_access_token()
+            
         if not self.token_info or self.token_info.is_expired():
             return None
         
@@ -234,8 +250,13 @@ class AuthManager:
         
     def invalidate_token(self) -> None:
         """Invalidate the current token, usually because it has expired or is invalid"""
+        # If using Pipeboard, delegate to the Pipeboard auth manager
+        if self.use_pipeboard:
+            pipeboard_auth_manager.invalidate_token()
+            return
+            
         if self.token_info:
-            print(f"Invalidating token: {self.token_info.access_token[:10]}...")
+            logger.info(f"Invalidating token: {self.token_info.access_token[:10]}...")
             self.token_info = None
             
             # Signal that authentication is needed
@@ -247,12 +268,12 @@ class AuthManager:
                 cache_path = self._get_token_cache_path()
                 if cache_path.exists():
                     os.remove(cache_path)
-                    print(f"Removed cached token file: {cache_path}")
+                    logger.info(f"Removed cached token file: {cache_path}")
             except Exception as e:
-                print(f"Error removing cached token: {e}")
+                logger.error(f"Error removing cached token file: {e}")
     
     def clear_token(self) -> None:
-        """Clear the current token and remove from cache"""
+        """Alias for invalidate_token for consistency with other APIs"""
         self.invalidate_token()
 
 
@@ -385,18 +406,55 @@ async def get_current_access_token() -> Optional[str]:
     app_id = meta_config.get_app_id()
     logger.debug(f"Current app_id: {app_id}")
     
+    # Check if using Pipeboard authentication
+    using_pipeboard = auth_manager.use_pipeboard
+    
+    # Check if app_id is valid - but only if not using Pipeboard authentication
+    if not app_id and not using_pipeboard:
+        logger.error("TOKEN VALIDATION FAILED: No valid app_id configured")
+        logger.error("Please set META_APP_ID environment variable or configure via meta_config.set_app_id()")
+        return None
+    
     # Attempt to get access token
     try:
         token = auth_manager.get_access_token()
         
         if token:
-            logger.debug("Access token found in auth_manager")
+            # Add basic token validation - check if it looks like a valid token
+            if len(token) < 20:  # Most Meta tokens are much longer
+                logger.error(f"TOKEN VALIDATION FAILED: Token appears malformed (length: {len(token)})")
+                auth_manager.invalidate_token()
+                return None
+                
+            logger.debug(f"Access token found in auth_manager (starts with: {token[:10]}...)")
             return token
         else:
             logger.warning("No valid access token available in auth_manager")
+            
+            # Check why token might be missing
+            if hasattr(auth_manager, 'token_info') and auth_manager.token_info:
+                if auth_manager.token_info.is_expired():
+                    logger.error("TOKEN VALIDATION FAILED: Token is expired")
+                    # Add expiration details
+                    if hasattr(auth_manager.token_info, 'expires_in') and auth_manager.token_info.expires_in:
+                        expiry_time = auth_manager.token_info.created_at + auth_manager.token_info.expires_in
+                        current_time = int(time.time())
+                        expired_seconds_ago = current_time - expiry_time
+                        logger.error(f"Token expired {expired_seconds_ago} seconds ago")
+                elif not auth_manager.token_info.access_token:
+                    logger.error("TOKEN VALIDATION FAILED: Token object exists but access_token is empty")
+                else:
+                    logger.error("TOKEN VALIDATION FAILED: Token exists but was rejected for unknown reason")
+            else:
+                logger.error("TOKEN VALIDATION FAILED: No token information available")
+                
+            # Suggest next steps for troubleshooting
+            logger.error("To fix: Try re-authenticating or check if your token has been revoked")
             return None
     except Exception as e:
         logger.error(f"Error getting access token: {str(e)}")
+        import traceback
+        logger.error(f"Token validation stacktrace: {traceback.format_exc()}")
         return None
 
 
@@ -443,4 +501,14 @@ def login():
 
 # Initialize auth manager with a placeholder - will be updated at runtime
 META_APP_ID = os.environ.get("META_APP_ID", "YOUR_META_APP_ID")
+
+# Only show warnings about missing META_APP_ID/META_APP_SECRET when not using Pipeboard
+if not os.environ.get("PIPEBOARD_API_TOKEN"):
+    # Log warnings about missing environment variables
+    if META_APP_ID == "YOUR_META_APP_ID":
+        logger.warning("META_APP_ID environment variable is not set. Authentication will not work properly.")
+    
+    if not os.environ.get("META_APP_SECRET"):
+        logger.warning("META_APP_SECRET environment variable is not set. Long-lived token exchange will not work.")
+
 auth_manager = AuthManager(META_APP_ID)