alita-sdk 0.3.257__py3-none-any.whl → 0.3.562__py3-none-any.whl

alita_sdk/configurations/github.py

@@ -84,4 +84,68 @@ class GithubConfiguration(BaseModel):
             "Authentication is misconfigured: provide either Token (access_token), "
             "Password (username + password), App private key (app_id + app_private_key), "
             "or leave all blank for anonymous access."
-        )
+        )
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check GitHub connection using provided settings.
+        Returns None if connection is successful, error message otherwise.
+        """
+        import requests
+        from requests.auth import HTTPBasicAuth
+        import jwt
+        import time
+
+        base_url = settings.get('base_url', 'https://api.github.com')
+        access_token = settings.get('access_token')
+        username = settings.get('username')
+        password = settings.get('password')
+        app_id = settings.get('app_id')
+        app_private_key = settings.get('app_private_key')
+
+        # if all auth methods are None or empty, allow anonymous access
+        if not any([access_token, (username and password), (app_id and app_private_key)]):
+            return None
+
+        headers = {'Accept': 'application/vnd.github.v3+json'}
+        auth = None
+
+        try:
+            # Determine authentication method
+            if access_token:
+                headers['Authorization'] = f'token {access_token}'
+            elif username and password:
+                auth = HTTPBasicAuth(username, password)
+            elif app_id and app_private_key:
+                # Generate JWT for GitHub App authentication
+                payload = {
+                    'iat': int(time.time()),
+                    'exp': int(time.time()) + 600,  # 10 minutes
+                    'iss': app_id
+                }
+                jwt_token = jwt.encode(payload, app_private_key, algorithm='RS256')
+                headers['Authorization'] = f'Bearer {jwt_token}'
+
+            # Test connection with user endpoint
+            response = requests.get(f'{base_url}/user', headers=headers, auth=auth, timeout=10)
+
+            if response.status_code == 200:
+                return None
+            elif response.status_code == 401:
+                return "Authentication failed: Invalid credentials"
+            elif response.status_code == 403:
+                return "Access forbidden: Check your permissions"
+            elif response.status_code == 404:
+                return "GitHub API endpoint not found"
+            else:
+                return f"Connection failed with status {response.status_code}: {response.text}"
+
+        except requests.exceptions.ConnectionError:
+            return "Connection error: Unable to reach GitHub API"
+        except requests.exceptions.Timeout:
+            return "Connection timeout: GitHub API did not respond in time"
+        except jwt.InvalidKeyError:
+            return "Invalid private key format for GitHub App authentication"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/gitlab.py

@@ -29,3 +29,84 @@ class GitlabConfiguration(BaseModel):
     )
     url: str = Field(description="GitLab URL")
     private_token: SecretStr = Field(description="GitLab private token")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to GitLab.
+        
+        Args:
+            settings: Dictionary containing GitLab configuration
+                - url: GitLab instance URL (required)
+                - private_token: GitLab private token for authentication (required)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        
+        # Validate url
+        url = settings.get("url", "").strip()
+        if not url:
+            return "GitLab URL is required"
+        
+        # Normalize URL - remove trailing slashes
+        url = url.rstrip("/")
+        
+        # Basic URL validation
+        if not url.startswith(("http://", "https://")):
+            return "GitLab URL must start with http:// or https://"
+        
+        # Validate private_token
+        private_token = settings.get("private_token")
+        if not private_token:
+            return "GitLab private token is required"
+        
+        # Extract token value if it's a SecretStr
+        token_value = private_token.get_secret_value() if hasattr(private_token, 'get_secret_value') else private_token
+        
+        if not token_value or not str(token_value).strip():
+            return "GitLab private token cannot be empty"
+        
+        # Test connection using /api/v4/user endpoint
+        # This endpoint returns current authenticated user info
+        test_url = f"{url}/api/v4/user"
+        
+        # GitLab supports both PRIVATE-TOKEN header and Authorization Bearer
+        # Using PRIVATE-TOKEN is GitLab-specific and more explicit
+        headers = {
+            "PRIVATE-TOKEN": str(token_value).strip()
+        }
+        
+        try:
+            response = requests.get(
+                test_url,
+                headers=headers,
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully connected and authenticated
+                return None
+            elif response.status_code == 401:
+                return "Authentication failed: invalid private token"
+            elif response.status_code == 403:
+                return "Access forbidden: token lacks required permissions"
+            elif response.status_code == 404:
+                return "GitLab API endpoint not found: verify the GitLab URL"
+            else:
+                return f"GitLab API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            if 'Hostname mismatch' in str(e):
+                return "GitLab API endpoint not found: verify the GitLab URL"
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to GitLab at {url}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to GitLab at {url} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to GitLab: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/google_places.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class GooglePlacesConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Google Places",
+                "icon_url": "google.svg",
+                "section": "credentials",
+                "type": "google_places",
+                "categories": ["other"],
+                "extra_categories": ["google", "places", "maps", "location", "geocoding"],
+            }
+        }
+    )
+    api_key: SecretStr = Field(description="Google Places API Key")

alita_sdk/configurations/jira.py

@@ -35,3 +35,106 @@ class JiraConfiguration(BaseModel):
     username: Optional[str] = Field(description="Jira Username", default=None)
     api_key: Optional[SecretStr] = Field(description="Jira API Key", default=None)
     token: Optional[SecretStr] = Field(description="Jira Token", default=None)
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check Jira connection using provided settings.
+        Returns None if connection is successful, error message otherwise.
+        
+        Tests authentication by calling the /rest/api/latest/myself endpoint,
+        which returns information about the currently authenticated user.
+        """
+        import requests
+        from requests.auth import HTTPBasicAuth
+
+        # Extract and validate settings
+        base_url = settings.get('base_url', '').rstrip('/')
+        username = settings.get('username')
+        api_key = settings.get('api_key')
+        token = settings.get('token')
+
+        # Validate base URL
+        if not base_url:
+            return "Base URL is required"
+        
+        if not base_url.startswith(('http://', 'https://')):
+            return "Base URL must start with http:// or https://"
+
+        # Validate authentication - at least one method must be provided
+        has_basic_auth = bool(username and api_key)
+        has_token = bool(token and str(token).strip())
+
+        if not (has_basic_auth or has_token):
+            return "Authentication required: Provide either username + API key, or bearer token"
+
+        # Setup authentication headers
+        headers = {'Accept': 'application/json'}
+        auth = None
+
+        if has_token:
+            # Bearer token authentication
+            token_value = token.get_secret_value() if hasattr(token, 'get_secret_value') else token
+            headers['Authorization'] = f'Bearer {token_value}'
+        elif has_basic_auth:
+            # Basic authentication
+            api_key_value = api_key.get_secret_value() if hasattr(api_key, 'get_secret_value') else api_key
+            auth = HTTPBasicAuth(username, api_key_value)
+
+        # Build API endpoint - using 'latest' for version independence
+        api_endpoint = f"{base_url}/rest/api/latest/myself"
+
+        try:
+            # Make authenticated request to verify credentials
+            response = requests.get(
+                api_endpoint,
+                headers=headers,
+                auth=auth,
+                timeout=10
+            )
+
+            # Handle different response codes
+            if response.status_code == 200:
+                return None  # Success - credentials are valid
+            
+            elif response.status_code == 401:
+                # Authentication failed
+                if has_token:
+                    return "Authentication failed: Invalid bearer token"
+                else:
+                    return "Authentication failed: Invalid username or API key"
+            
+            elif response.status_code == 403:
+                # Authenticated but insufficient permissions
+                return "Access forbidden: Your account has insufficient permissions to access Jira API"
+            
+            elif response.status_code == 404:
+                # API endpoint not found - likely wrong URL
+                return "Jira API endpoint not found: Verify your base URL (e.g., 'https://yourinstance.atlassian.net')"
+            
+            else:
+                # Other HTTP errors - try to extract Jira error messages
+                error_detail = ""
+                try:
+                    error_json = response.json()
+                    if 'errorMessages' in error_json and error_json['errorMessages']:
+                        error_detail = ": " + ", ".join(error_json['errorMessages'])
+                    elif 'message' in error_json:
+                        error_detail = f": {error_json['message']}"
+                except:
+                    pass
+                
+                return f"Connection failed with status {response.status_code}{error_detail}"
+
+        except requests.exceptions.SSLError:
+            return "SSL certificate verification failed: Check your Jira URL or network settings"
+        except requests.exceptions.ConnectionError:
+            return "Connection error: Unable to reach Jira server - check URL and network connectivity"
+        except requests.exceptions.Timeout:
+            return "Connection timeout: Jira server did not respond within 10 seconds"
+        except requests.exceptions.MissingSchema:
+            return "Invalid URL format: URL must include protocol (http:// or https://)"
+        except requests.exceptions.InvalidURL:
+            return "Invalid URL format: Please check your Jira base URL"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/openapi.py

@@ -0,0 +1,111 @@
+from typing import Any, Literal, Optional
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, model_validator
+
+
+class OpenApiConfiguration(BaseModel):
+    model_config = ConfigDict(
+        extra='allow',
+        json_schema_extra={
+            "metadata": {
+                "label": "OpenAPI",
+                "icon_url": "openapi.svg",
+                "categories": ["integrations"],
+                "type": "openapi",
+                "extra_categories": ["api", "openapi", "swagger"],
+                "sections": {
+                    "auth": {
+                        "required": False,
+                        "subsections": [
+                            {
+                                "name": "API Key",
+                                "fields": ["api_key", "auth_type", "custom_header_name"],
+                            },
+                            {
+                                "name": "OAuth",
+                                "fields": [
+                                    "client_id",
+                                    "client_secret",
+                                    "auth_url",
+                                    "token_url",
+                                    "scope",
+                                    "method",
+                                ],
+                            },
+                        ],
+                    },
+                },
+                "section": "credentials",
+            }
+        }
+    )
+
+    api_key: Optional[SecretStr] = Field(
+        default=None,
+        description=(
+            "API key value (stored as a secret). Used when selecting 'API Key' authentication subsection."
+        ),
+    )
+    auth_type: Optional[Literal['Basic', 'Bearer', 'Custom']] = Field(
+        default='Bearer',
+        description=(
+            "How to apply the API key. "
+            "- 'Bearer': sets 'Authorization: Bearer <api_key>' "
+            "- 'Basic': sets 'Authorization: Basic <api_key>' "
+            "- 'custom': sets '<custom_header_name>: <api_key>'"
+        ),
+    )
+    custom_header_name: Optional[str] = Field(
+        default=None,
+        description="Custom header name to use when auth_type='custom' (e.g. 'X-Api-Key').",
+        json_schema_extra={'visible_when': {'field': 'auth_type', 'value': 'custom'}},
+    )
+
+    client_id: Optional[str] = Field(default=None, description='OAuth client ID')
+    client_secret: Optional[SecretStr] = Field(default=None, description='OAuth client secret (stored as a secret)')
+    auth_url: Optional[str] = Field(default=None, description='OAuth authorization URL')
+    token_url: Optional[str] = Field(default=None, description='OAuth token URL')
+    scope: Optional[str] = Field(default=None, description='OAuth scope(s)')
+    method: Optional[Literal['default', 'Basic']] = Field(
+        default='default',
+        description=(
+            "Token exchange method. 'default' uses standard POST body; 'Basic' uses a Basic authorization header."
+        ),
+    )
+
+    @model_validator(mode='before')
+    @classmethod
+    def _validate_auth_consistency(cls, values):
+        if not isinstance(values, dict):
+            return values
+
+        # OAuth: if any OAuth field is provided, require the key ones.
+        has_any_oauth = any(
+            (values.get('client_id'), values.get('client_secret'), values.get('auth_url'), values.get('token_url'))
+        )
+        if has_any_oauth:
+            missing = []
+            if not values.get('client_id'):
+                missing.append('client_id')
+            if not values.get('client_secret'):
+                missing.append('client_secret')
+            if not values.get('token_url'):
+                missing.append('token_url')
+            if missing:
+                raise ValueError(f"OAuth is misconfigured; missing: {', '.join(missing)}")
+
+        # API key: if auth_type is custom, custom_header_name must be present.
+        auth_type = values.get('auth_type')
+        if isinstance(auth_type, str) and auth_type.strip().lower() == 'custom' and values.get('api_key'):
+            if not values.get('custom_header_name'):
+                raise ValueError("custom_header_name is required when auth_type='custom'")
+
+        return values
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """Best-effort validation for OpenAPI credentials.
+
+        This model is intended to store reusable credentials only.
+        Spec/base_url validation happens at toolkit configuration level.
+        """
+        return None

alita_sdk/configurations/postman.py

@@ -22,7 +22,7 @@ class PostmanConfiguration(BaseModel):
                 },
                 "section": "credentials",
                 "type": "postman",
-                "categories": ["api testing"],
+                "categories": ["other"],
                 "extra_categories": ["postman", "api", "testing", "collection"],
             }
         }

alita_sdk/configurations/qtest.py

@@ -1,5 +1,6 @@
-from typing import Optional
+import re
 
+import requests
 from pydantic import BaseModel, ConfigDict, Field, SecretStr
 
 
@@ -16,6 +17,74 @@ class QtestConfiguration(BaseModel):
             }
         }
     )
-    base_url: str = Field(description="QTest base url")
-    qtest_api_token: Optional[SecretStr] = Field(description="QTest API token", default=None)
+    base_url: str = Field(description="QTest base URL")
+    qtest_api_token: SecretStr = Field(description="QTest API token")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """Check connectivity and credentials for qTest.
+
+        Strategy:
+        - Validate token against an auth-required endpoint (so an incorrect token is detected).
+
+        Returns:
+            None if successful, otherwise a short actionable error message.
+        """
+        base_url_input = settings.get("base_url")
+        base_url = base_url_input.strip() if isinstance(base_url_input, str) else ""
+        if not base_url:
+            return "QTest base URL is required"
+
+        if not base_url.startswith(("http://", "https://")):
+            return "QTest base URL must start with http:// or https://"
+
+        base_url = base_url.rstrip("/")
+        # If user pasted /api/v3 (or similar), strip it so we can build canonical API URLs.
+        base_url = re.sub(r"/api/v\d+/?$", "", base_url, flags=re.IGNORECASE)
+
+        token = settings.get("qtest_api_token")
+        if token is None:
+            return "QTest API token is required"
+        token_value = token.get_secret_value() if hasattr(token, "get_secret_value") else str(token)
+        if not token_value or not token_value.strip():
+            return "QTest API token cannot be empty"
+
+        headers = {
+            "Authorization": f"Bearer {token_value}",
+            "Content-Type": "application/json",
+        }
+
+        # Auth-required endpoint to validate the token.
+        # /projects works on v3 and requires auth in typical qTest deployments.
+        token_check_url = f"{base_url}/api/v3/projects?pageSize=1&page=1"
+
+        try:
+            resp = requests.get(token_check_url, headers=headers, timeout=10)
+            if resp.status_code == 200:
+                return None
+            elif resp.status_code == 401:
+                return "Invalid or expired QTest API token"
+            elif resp.status_code == 403:
+                return "Access forbidden - token lacks required permissions"
+            elif resp.status_code == 404:
+                return "QTest API not found (404) - verify base URL (do not include /api/v3)"
+            elif resp.status_code == 429:
+                return "Rate limited (429) - please try again later"
+            elif 500 <= resp.status_code <= 599:
+                return f"QTest service error (HTTP {resp.status_code})"
+            else:
+                return f"QTest connection failed (HTTP {resp.status_code})"
+
+        except requests.exceptions.Timeout:
+            return "Connection timeout - qTest did not respond within 10 seconds"
+        except requests.exceptions.ConnectionError:
+            return "Connection error - unable to reach qTest. Check base URL and network."
+        except requests.exceptions.SSLError:
+            return "SSL error - certificate verification failed"
+        except requests.exceptions.RequestException as e:
+            return f"Request failed: {str(e)}"
+        except Exception:
+            return "Unexpected error during qTest connection check"
+
+
 

alita_sdk/configurations/report_portal.py

@@ -0,0 +1,115 @@
+from urllib.parse import quote, urlparse, urlunparse
+
+import requests
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class ReportPortalConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Report Portal",
+                "icon_url": "report_portal.svg",
+                "section": "credentials",
+                "type": "report_portal",
+                "categories": ["testing"],
+                "extra_categories": ["report portal", "testing", "automation", "reports"],
+            }
+        }
+    )
+    project: str = Field(description="Report Portal Project Name")
+    endpoint: str = Field(description="Report Portal Endpoint URL")
+    api_key: SecretStr = Field(description="Report Portal API Key")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """Check the connection to ReportPortal.
+
+        Validates:
+        - endpoint URL format and reachability
+        - API key (token) via an auth-required endpoint
+        - project access (because most ReportPortal APIs are scoped to a project)
+
+        Returns:
+            None if connection successful, error message string otherwise
+        """
+        endpoint_in = settings.get("endpoint")
+        endpoint = endpoint_in.strip() if isinstance(endpoint_in, str) else ""
+        if not endpoint:
+            return "Endpoint is required"
+
+        if not endpoint.startswith(("http://", "https://")):
+            return "Endpoint must start with http:// or https://"
+
+        # Normalize: remove query/fragment and trailing slash.
+        parsed = urlparse(endpoint)
+        endpoint = urlunparse(parsed._replace(query="", fragment="")).rstrip("/")
+
+        # If user pasted an API URL, normalize back to base endpoint.
+        # Common pastes: .../api/v1 or .../api/v1/<project>
+        # lowered = endpoint.lower()
+        # for suffix in ("/api/v1", "/api"):
+        #     if lowered.endswith(suffix):
+        #         endpoint = endpoint[: -len(suffix)].rstrip("/")
+        #         lowered = endpoint.lower()
+        #         break
+
+        project_in = settings.get("project")
+        project = project_in.strip() if isinstance(project_in, str) else ""
+        if not project:
+            return "Project is required"
+
+        api_key = settings.get("api_key")
+        if api_key is None:
+            return "API key is required"
+        api_key_value = api_key.get_secret_value() if hasattr(api_key, "get_secret_value") else str(api_key)
+        if not api_key_value or not api_key_value.strip():
+            return "API key cannot be empty"
+
+        # Auth-required endpoint for verification.
+        # /user endpoint validates the token and project context.
+        project_encoded = quote(project, safe="")
+        test_url = f"{endpoint}/api/v1/project/{project_encoded}"
+
+        try:
+            resp = requests.get(
+                test_url,
+                headers={"Authorization": f"Bearer {api_key_value}"},
+                timeout=10,
+            )
+
+            if resp.status_code == 200:
+                return None
+            if resp.status_code == 401:
+                return "Invalid API key"
+            if resp.status_code == 403:
+                return "Access forbidden - API key has no access to this project"
+            if resp.status_code == 404:
+                return "API endpoint not found (404) - verify endpoint URL and project name"
+            if resp.status_code == 429:
+                return "Rate limited (429) - please try again later"
+            if 500 <= resp.status_code <= 599:
+                return f"ReportPortal service error (HTTP {resp.status_code})"
+            return f"Connection failed (HTTP {resp.status_code})"
+
+        except requests.exceptions.Timeout:
+            return "Connection timeout - ReportPortal did not respond within 10 seconds"
+        except requests.exceptions.SSLError as e:
+            if "Hostname mismatch" in str(e):
+                return "API endpoint not found - verify endpoint URL and project name"
+            return "SSL error - certificate verification failed"
+        except requests.exceptions.ConnectionError:
+            return "Connection error - unable to reach ReportPortal. Check endpoint URL and network."
+        except requests.exceptions.RequestException as e:
+            return f"Request failed: {str(e)}"
+        except Exception:
+            return "Unexpected error during ReportPortal connection check"
+
+if __name__ == '__main__':
+    settings = {
+        "endpoint": "https://reportportal.epam.com",
+        "project": "epm-alta",
+        "api_key": "my-api-key_U1kF0zFvToqcweG3x552cI8pnYkMqszgtht_LHGZhpxwrxDl5nXlmrSf_JLEE8jy",
+    }
+
+    print(ReportPortalConfiguration.check_connection(settings))

alita_sdk/configurations/salesforce.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class SalesforceConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Salesforce",
+                "icon_url": "salesforce.svg",
+                "section": "credentials",
+                "type": "salesforce",
+                "categories": ["other"],
+                "extra_categories": ["salesforce", "crm", "sales", "customer"],
+            }
+        }
+    )
+    client_id: str = Field(description="Salesforce Client ID")
+    client_secret: SecretStr = Field(description="Salesforce Client Secret")
+    base_url: str = Field(description="Salesforce Base URL")

alita_sdk/configurations/service_now.py

@@ -9,20 +9,9 @@ class ServiceNowConfiguration(BaseModel):
             "metadata": {
                 "label": "ServiceNow",
                 "icon_url": "servicenow.svg",
-                "sections": {
-                    "auth": {
-                        "required": True,
-                        "subsections": [
-                            {
-                                "name": "Username & Password",
-                                "fields": ["username", "password"]
-                            }
-                        ]
-                    },
-                },
                 "section": "credentials",
                 "type": "service_now",
-                "categories": ["service management"],
+                "categories": ["other"],
                 "extra_categories": ["servicenow", "itsm", "service management", "incident"],
             }
         }