binalyze-air-sdk 1.0.1__py3-none-any.whl

binalyze_air/commands/interact.py

@@ -0,0 +1,58 @@
+"""
+Interact commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any, Union
+
+from ..base import Command
+from ..models.interact import (
+    InteractiveShellTaskResponse, AssignInteractiveShellTaskRequest,
+    ShellTaskResponse, AssignShellTaskRequest  # Legacy models
+)
+from ..http_client import HTTPClient
+
+
+class AssignInteractiveShellTaskCommand(Command[InteractiveShellTaskResponse]):
+    """Command to assign an interactive shell task."""
+    
+    def __init__(self, http_client: HTTPClient, request: Union[AssignInteractiveShellTaskRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.request = request
+    
+    def execute(self) -> InteractiveShellTaskResponse:
+        """Execute the command to assign an interactive shell task."""
+        # Handle both dict and model objects
+        if isinstance(self.request, dict):
+            payload = self.request
+        else:
+            payload = self.request.model_dump(exclude_none=True, by_alias=True)
+        
+        response = self.http_client.post("interact/shell/assign-task", json_data=payload)
+        
+        if response.get("success"):
+            result_data = response.get("result", {})
+            # Use Pydantic parsing with proper field aliasing
+            return InteractiveShellTaskResponse.model_validate(result_data)
+        
+        raise Exception(f"Failed to assign interactive shell task: {response.get('errors', [])}")
+
+
+# Legacy command for backward compatibility (deprecated)
+class AssignShellTaskCommand(Command[ShellTaskResponse]):
+    """Command to assign a shell interaction task (legacy)."""
+    
+    def __init__(self, http_client: HTTPClient, request: Union[AssignShellTaskRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.request = request
+    
+    def execute(self) -> ShellTaskResponse:
+        """Execute the command to assign a shell task (legacy)."""
+        # Handle both dict and model objects
+        if isinstance(self.request, dict):
+            payload = self.request
+        else:
+            payload = self.request.model_dump(exclude_none=True)
+        
+        response = self.http_client.post("interact/shell/assign-task", json_data=payload)
+        
+        return ShellTaskResponse(**response.get("result", {})) 

binalyze_air/commands/organizations.py

@@ -0,0 +1,221 @@
+"""
+Organization-related commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any, List
+
+from ..base import Command
+from ..models.organizations import (
+    Organization, OrganizationUser, CreateOrganizationRequest, 
+    UpdateOrganizationRequest, AddUserToOrganizationRequest, OrganizationSettings,
+    AssignUsersToOrganizationRequest, AddTagsToOrganizationRequest,
+    DeleteTagsFromOrganizationRequest, UpdateShareableDeploymentSettingsRequest,
+    UpdateDeploymentTokenRequest, DeploymentTokenUpdateResponse
+)
+from ..http_client import HTTPClient
+
+
+class CreateOrganizationCommand(Command[Organization]):
+    """Command to create a new organization."""
+    
+    def __init__(self, http_client: HTTPClient, request: CreateOrganizationRequest):
+        self.http_client = http_client
+        self.request = request
+    
+    def execute(self) -> Organization:
+        """Execute the command to create an organization."""
+        data = self.request.model_dump(exclude_none=True, by_alias=True)
+        
+        response = self.http_client.post("organizations", json_data=data)
+        
+        entity_data = response.get("result", {})
+        
+        # Use Pydantic model_validate for automatic field mapping via aliases
+        return Organization.model_validate(entity_data)
+
+
+class UpdateOrganizationCommand(Command[Organization]):
+    """Command to update an existing organization."""
+    
+    def __init__(self, http_client: HTTPClient, organization_id: str, request: UpdateOrganizationRequest):
+        self.http_client = http_client
+        self.organization_id = organization_id
+        self.request = request
+    
+    def execute(self) -> Organization:
+        """Execute the command to update an organization."""
+        data = self.request.model_dump(exclude_none=True, by_alias=True)
+        
+        response = self.http_client.patch(f"organizations/{self.organization_id}", json_data=data)
+        
+        entity_data = response.get("result", {})
+        
+        # Use Pydantic model_validate for automatic field mapping via aliases
+        return Organization.model_validate(entity_data)
+
+
+class DeleteOrganizationCommand(Command[Dict[str, Any]]):
+    """Command to delete an organization."""
+    
+    def __init__(self, http_client: HTTPClient, organization_id: str):
+        self.http_client = http_client
+        self.organization_id = organization_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to delete an organization."""
+        response = self.http_client.delete(f"organizations/{self.organization_id}")
+        return response
+
+
+class AssignUsersToOrganizationCommand(Command[bool]):
+    """Command to assign multiple users to an organization using the /assign-users endpoint."""
+    
+    def __init__(self, http_client: HTTPClient, organization_id: str, request: AssignUsersToOrganizationRequest):
+        self.http_client = http_client
+        self.organization_id = organization_id
+        self.request = request
+    
+    def execute(self) -> bool:
+        """Execute the command to assign users to organization."""
+        data = self.request.model_dump(exclude_none=True, by_alias=True)
+        
+        response = self.http_client.post(f"organizations/{self.organization_id}/assign-users", json_data=data)
+        
+        return response.get("success", False)
+
+
+class RemoveUserFromOrganizationCommand(Command[Dict[str, Any]]):
+    """Command to remove a user from an organization using the /remove-user/{userId} endpoint."""
+    
+    def __init__(self, http_client: HTTPClient, organization_id: str, user_id: str):
+        self.http_client = http_client
+        self.organization_id = organization_id
+        self.user_id = user_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to remove user from organization."""
+        response = self.http_client.delete(f"organizations/{self.organization_id}/remove-user/{self.user_id}")
+        
+        return response
+
+
+class AddTagsToOrganizationCommand(Command[Organization]):
+    """Command to add tags to an organization."""
+    
+    def __init__(self, http_client: HTTPClient, organization_id: str, request: AddTagsToOrganizationRequest):
+        self.http_client = http_client
+        self.organization_id = organization_id
+        self.request = request
+    
+    def execute(self) -> Organization:
+        """Execute the command to add tags to organization."""
+        data = self.request.model_dump(exclude_none=True, by_alias=True)
+        
+        response = self.http_client.patch(f"organizations/{self.organization_id}/tags", json_data=data)
+        
+        entity_data = response.get("result", {})
+        
+        # Use Pydantic model_validate for automatic field mapping
+        return Organization.model_validate(entity_data)
+
+
+class DeleteTagsFromOrganizationCommand(Command[Organization]):
+    """Command to delete tags from an organization."""
+    
+    def __init__(self, http_client: HTTPClient, organization_id: str, request: DeleteTagsFromOrganizationRequest):
+        self.http_client = http_client
+        self.organization_id = organization_id
+        self.request = request
+    
+    def execute(self) -> Organization:
+        """Execute the command to delete tags from organization."""
+        data = self.request.model_dump(exclude_none=True, by_alias=True)
+        
+        response = self.http_client.delete(f"organizations/{self.organization_id}/tags", json_data=data)
+        
+        entity_data = response.get("result", {})
+        
+        # Use Pydantic model_validate for automatic field mapping
+        return Organization.model_validate(entity_data)
+
+
+class UpdateShareableDeploymentSettingsCommand(Command[bool]):
+    """Command to update organization shareable deployment settings."""
+    
+    def __init__(self, http_client: HTTPClient, organization_id: str, request: UpdateShareableDeploymentSettingsRequest):
+        self.http_client = http_client
+        self.organization_id = organization_id
+        self.request = request
+    
+    def execute(self) -> bool:
+        """Execute the command to update shareable deployment settings."""
+        data = self.request.model_dump(exclude_none=True, by_alias=True)
+        
+        response = self.http_client.post(f"organizations/{self.organization_id}/shareable-deployment", json_data=data)
+        
+        return response.get("success", False)
+
+
+class UpdateDeploymentTokenCommand(Command[DeploymentTokenUpdateResponse]):
+    """Command to update organization deployment token."""
+    
+    def __init__(self, http_client: HTTPClient, organization_id: str):
+        self.http_client = http_client
+        self.organization_id = organization_id
+    
+    def execute(self) -> DeploymentTokenUpdateResponse:
+        """Execute the command to update deployment token."""
+        response = self.http_client.post(f"organizations/{self.organization_id}/deployment-token")
+        
+        # Use Pydantic model_validate for automatic field mapping
+        return DeploymentTokenUpdateResponse.model_validate(response)
+
+
+class UpdateOrganizationSettingsCommand(Command[OrganizationSettings]):
+    """Command to update organization settings."""
+    
+    def __init__(self, http_client: HTTPClient, organization_id: str, settings: Dict[str, Any]):
+        self.http_client = http_client
+        self.organization_id = organization_id
+        self.settings = settings
+    
+    def execute(self) -> OrganizationSettings:
+        """Execute the command to update organization settings."""
+        response = self.http_client.put(f"organizations/{self.organization_id}/settings", json_data=self.settings)
+        
+        entity_data = response.get("result", {})
+        
+        mapped_data = {
+            "organization_id": entity_data.get("organizationId"),
+            "retention_policy": entity_data.get("retentionPolicy", {}),
+            "security_settings": entity_data.get("securitySettings", {}),
+            "notification_settings": entity_data.get("notificationSettings", {}),
+            "api_settings": entity_data.get("apiSettings", {}),
+            "custom_settings": entity_data.get("customSettings", {}),
+        }
+        
+        # Remove None values
+        mapped_data = {k: v for k, v in mapped_data.items() if v is not None}
+        
+        return OrganizationSettings(**mapped_data)
+
+
+# Legacy command for backward compatibility
+class AddUserToOrganizationCommand(Command[OrganizationUser]):
+    """Legacy command to add a user to an organization (use AssignUsersToOrganizationCommand for new implementations)."""
+    
+    def __init__(self, http_client: HTTPClient, organization_id: str, request: AddUserToOrganizationRequest):
+        self.http_client = http_client
+        self.organization_id = organization_id
+        self.request = request
+    
+    def execute(self) -> OrganizationUser:
+        """Execute the command to add user to organization."""
+        data = self.request.model_dump(exclude_none=True)
+        
+        response = self.http_client.post(f"organizations/{self.organization_id}/users", json_data=data)
+        
+        entity_data = response.get("result", {})
+        
+        # Use Pydantic model_validate for automatic field mapping
+        return OrganizationUser.model_validate(entity_data) 

binalyze_air/commands/policies.py

@@ -0,0 +1,203 @@
+"""
+Policy-related commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any, List, Optional, Union
+
+from ..base import Command
+from ..models.policies import (
+    CreatePolicyRequest, UpdatePolicyRequest, UpdatePoliciesPrioritiesRequest, 
+    Policy, PolicyPriority, AssignPolicyRequest
+)
+from ..http_client import HTTPClient
+
+
+class CreatePolicyCommand(Command[Policy]):
+    """Command to create a new policy."""
+    
+    def __init__(self, http_client: HTTPClient, policy_data: Union[CreatePolicyRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.policy_data = policy_data
+    
+    def execute(self) -> Policy:
+        """Execute the create policy command."""
+        # Handle both dict and model objects
+        if isinstance(self.policy_data, dict):
+            payload = self.policy_data.copy()
+        else:
+            # Convert model to dict using model_dump with aliases
+            payload = self.policy_data.model_dump(by_alias=True, exclude_none=True)
+        
+        response = self.http_client.post("policies", json_data=payload)
+        
+        # Parse using Pydantic models with automatic field mapping
+        return Policy.model_validate(response.get("result", {}))
+
+
+class UpdatePolicyCommand(Command[Policy]):
+    """Command to update an existing policy."""
+    
+    def __init__(self, http_client: HTTPClient, policy_id: str, update_data: Union[UpdatePolicyRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.policy_id = policy_id
+        self.update_data = update_data
+    
+    def execute(self) -> Policy:
+        """Execute the update policy command."""
+        # Handle both dict and model objects
+        if isinstance(self.update_data, dict):
+            payload = self.update_data.copy()
+        else:
+            # Convert model to dict using model_dump with aliases
+            payload = self.update_data.model_dump(by_alias=True, exclude_none=True)
+        
+        response = self.http_client.put(f"policies/{self.policy_id}", json_data=payload)
+        
+        # Parse using Pydantic models with automatic field mapping
+        return Policy.model_validate(response.get("result", {}))
+
+
+class UpdatePoliciesPrioritiesCommand(Command[Dict[str, Any]]):
+    """Command to update policy priorities."""
+    
+    def __init__(self, http_client: HTTPClient, priorities_data: Union[UpdatePoliciesPrioritiesRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.priorities_data = priorities_data
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the update policy priorities command."""
+        # Handle both dict and model objects
+        if isinstance(self.priorities_data, dict):
+            payload = self.priorities_data.copy()
+        else:
+            # Convert model to dict using model_dump with aliases
+            payload = self.priorities_data.model_dump(by_alias=True, exclude_none=True)
+        
+        return self.http_client.put("policies/priorities", json_data=payload)
+
+
+class DeletePolicyCommand(Command[Dict[str, Any]]):
+    """Command to delete a policy."""
+    
+    def __init__(self, http_client: HTTPClient, policy_id: str):
+        self.http_client = http_client
+        self.policy_id = policy_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the delete policy command."""
+        return self.http_client.delete(f"policies/{self.policy_id}")
+
+
+class AssignPolicyCommand(Command[Dict[str, Any]]):
+    """Command to assign policy to endpoints."""
+    
+    def __init__(self, http_client: HTTPClient, assignment_data: Union[AssignPolicyRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.assignment_data = assignment_data
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the assign policy command."""
+        # Handle both dict and model objects
+        if isinstance(self.assignment_data, dict):
+            payload = self.assignment_data.copy()
+        else:
+            payload = {
+                "policyId": self.assignment_data.policy_id,
+                "endpointIds": self.assignment_data.endpoint_ids,
+                "organizationIds": self.assignment_data.organization_ids,
+            }
+            
+            if self.assignment_data.filter_params:
+                payload["filter"] = self.assignment_data.filter_params
+        
+        return self.http_client.post("policies/assign", json_data=payload)
+
+
+class UnassignPolicyCommand(Command[Dict[str, Any]]):
+    """Command to unassign policy from endpoints."""
+    
+    def __init__(self, http_client: HTTPClient, policy_id: str, endpoint_ids: List[str]):
+        self.http_client = http_client
+        self.policy_id = policy_id
+        self.endpoint_ids = endpoint_ids
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the unassign policy command."""
+        payload = {
+            "policyId": self.policy_id,
+            "endpointIds": self.endpoint_ids,
+        }
+        
+        return self.http_client.post("policies/unassign", json_data=payload)
+
+
+class ExecutePolicyCommand(Command[Dict[str, Any]]):
+    """Command to execute a policy on assigned endpoints."""
+    
+    def __init__(self, http_client: HTTPClient, policy_id: str, endpoint_ids: Optional[List[str]] = None):
+        self.http_client = http_client
+        self.policy_id = policy_id
+        self.endpoint_ids = endpoint_ids
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the policy execution command."""
+        payload = {"policyId": self.policy_id}
+        
+        if self.endpoint_ids:
+            payload["endpointIds"] = self.endpoint_ids
+        
+        return self.http_client.post("policies/execute", json_data=payload)
+
+
+class ActivatePolicyCommand(Command[Policy]):
+    """Command to activate a policy."""
+    
+    def __init__(self, http_client: HTTPClient, policy_id: str):
+        self.http_client = http_client
+        self.policy_id = policy_id
+    
+    def execute(self) -> Policy:
+        """Execute the activate policy command."""
+        payload = {"status": "active"}
+        response = self.http_client.put(f"policies/{self.policy_id}", json_data=payload)
+        
+        entity_data = response.get("result", {})
+        return Policy(
+            id=entity_data.get("_id", self.policy_id),
+            name=entity_data.get("name", ""),
+            description=entity_data.get("description"),
+            type=entity_data.get("type", "custom"),
+            status=entity_data.get("status", "active"),
+            organization_ids=entity_data.get("organizationIds", [0]),
+            created_by=entity_data.get("createdBy", ""),
+            created_at=entity_data.get("createdAt"),
+            rules=entity_data.get("rules", []),
+            tags=entity_data.get("tags", [])
+        )
+
+
+class DeactivatePolicyCommand(Command[Policy]):
+    """Command to deactivate a policy."""
+    
+    def __init__(self, http_client: HTTPClient, policy_id: str):
+        self.http_client = http_client
+        self.policy_id = policy_id
+    
+    def execute(self) -> Policy:
+        """Execute the deactivate policy command."""
+        payload = {"status": "inactive"}
+        response = self.http_client.put(f"policies/{self.policy_id}", json_data=payload)
+        
+        entity_data = response.get("result", {})
+        return Policy(
+            id=entity_data.get("_id", self.policy_id),
+            name=entity_data.get("name", ""),
+            description=entity_data.get("description"),
+            type=entity_data.get("type", "custom"),
+            status=entity_data.get("status", "inactive"),
+            organization_ids=entity_data.get("organizationIds", [0]),
+            created_by=entity_data.get("createdBy", ""),
+            created_at=entity_data.get("createdAt"),
+            rules=entity_data.get("rules", []),
+            tags=entity_data.get("tags", [])
+        ) 

binalyze_air/commands/settings.py

@@ -0,0 +1,29 @@
+"""
+Settings commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any, Union
+
+from ..base import Command
+from ..models.settings import BannerSettings, UpdateBannerSettingsRequest
+from ..http_client import HTTPClient
+
+
+class UpdateBannerSettingsCommand(Command[BannerSettings]):
+    """Command to update banner settings."""
+    
+    def __init__(self, http_client: HTTPClient, request: Union[UpdateBannerSettingsRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.request = request
+    
+    def execute(self):
+        """Execute the update banner settings command."""
+        # Handle both dict and model objects
+        if isinstance(self.request, dict):
+            payload = self.request
+        else:
+            # Use by_alias=True to ensure field aliases are properly mapped to API field names
+            payload = self.request.model_dump(exclude_none=True, by_alias=True)
+        
+        response = self.http_client.put("settings/banner", json_data=payload)
+        return response 

binalyze_air/commands/tasks.py

@@ -0,0 +1,56 @@
+"""
+Task-related commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any
+
+from ..base import Command
+from ..http_client import HTTPClient
+
+
+class CancelTaskCommand(Command[Dict[str, Any]]):
+    """Command to cancel a task."""
+    
+    def __init__(self, http_client: HTTPClient, task_id: str):
+        self.http_client = http_client
+        self.task_id = task_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the cancel task command."""
+        return self.http_client.post(f"tasks/{self.task_id}/cancel", json_data={})
+
+
+class CancelTaskAssignmentCommand(Command[Dict[str, Any]]):
+    """Command to cancel a task assignment."""
+    
+    def __init__(self, http_client: HTTPClient, assignment_id: str):
+        self.http_client = http_client
+        self.assignment_id = assignment_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the cancel task assignment command."""
+        return self.http_client.post(f"tasks/assignments/{self.assignment_id}/cancel", json_data={})
+
+
+class DeleteTaskAssignmentCommand(Command[Dict[str, Any]]):
+    """Command to delete a task assignment."""
+    
+    def __init__(self, http_client: HTTPClient, assignment_id: str):
+        self.http_client = http_client
+        self.assignment_id = assignment_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the delete task assignment command."""
+        return self.http_client.delete(f"tasks/assignments/{self.assignment_id}")
+
+
+class DeleteTaskCommand(Command[Dict[str, Any]]):
+    """Command to delete a task."""
+    
+    def __init__(self, http_client: HTTPClient, task_id: str):
+        self.http_client = http_client
+        self.task_id = task_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the delete task command."""
+        return self.http_client.delete(f"tasks/{self.task_id}")