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

binalyze_air/commands/interact.py

@@ -1,58 +1,172 @@
-"""
-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", {})) 
+"""
+Interact commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any, Union, List, Optional
+import json
+
+from ..base import Command
+from ..models.interact import (
+    InteractiveShellTaskResponse, AssignInteractiveShellTaskRequest,
+    ExecuteCommandRequest, ExecuteCommandResponse, LibraryFile,
+    InterruptCommandRequest, CloseSessionRequest, FileExistsResponse
+)
+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', [])}")
+
+
+# LIBRARY FILE COMMANDS
+
+class UploadFileToLibraryCommand(Command[Optional[LibraryFile]]):
+    """Command to upload a file to the library."""
+    
+    def __init__(self, http_client: HTTPClient, file_content: bytes, filename: str, organization_ids: Optional[List[int]] = None):
+        self.http_client = http_client
+        self.file_content = file_content
+        self.filename = filename
+        self.organization_ids = organization_ids
+    
+    def execute(self) -> Optional[LibraryFile]:
+        """Execute the command to upload a file to the library."""
+        # Prepare multipart form data
+        files = {"file": (self.filename, self.file_content)}
+        data = {}
+        
+        if self.organization_ids:
+            # API expects organizationIds as JSON string array, not comma-separated
+            data["organizationIds"] = json.dumps(self.organization_ids)
+        
+        response = self.http_client.upload_multipart("interact/library/upload", files=files, data=data)
+        
+        result_data = response.get("result")
+        # Handle null result properly - API may return null on success
+        if result_data is None:
+            return None
+        
+        return LibraryFile.model_validate(result_data)
+
+
+class DeleteFileFromLibraryCommand(Command[Dict[str, Any]]):
+    """Command to delete a file from the library."""
+    
+    def __init__(self, http_client: HTTPClient, filename: str):
+        self.http_client = http_client
+        self.filename = filename
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to delete a file from the library."""
+        params = {"filename": self.filename}
+        response = self.http_client.delete("interact/library/delete", params=params)
+        
+        return response
+
+
+# SHELL SESSION COMMANDS
+
+class ExecuteCommandCommand(Command[ExecuteCommandResponse]):
+    """Command to execute a command in a shell session."""
+    
+    def __init__(self, http_client: HTTPClient, session_id: str, request: Union[ExecuteCommandRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.session_id = session_id
+        self.request = request
+    
+    def execute(self) -> ExecuteCommandResponse:
+        """Execute the command in the shell session."""
+        # 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(
+            f"interact/shell/sessions/{self.session_id}/execute-command",
+            json_data=payload
+        )
+        
+        result_data = response.get("result", {})
+        return ExecuteCommandResponse.model_validate(result_data)
+
+
+class ExecuteAsyncCommandCommand(Command[ExecuteCommandResponse]):
+    """Command to execute an async command in a shell session."""
+    
+    def __init__(self, http_client: HTTPClient, session_id: str, request: Union[ExecuteCommandRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.session_id = session_id
+        self.request = request
+    
+    def execute(self) -> ExecuteCommandResponse:
+        """Execute the async command in the shell session."""
+        # 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(
+            f"interact/shell/sessions/{self.session_id}/execute-async-command",
+            json_data=payload
+        )
+        
+        result_data = response.get("result", {})
+        return ExecuteCommandResponse.model_validate(result_data)
+
+
+class InterruptCommandCommand(Command[Dict[str, Any]]):
+    """Command to interrupt a command in a shell session."""
+    
+    def __init__(self, http_client: HTTPClient, session_id: str, message_id: str):
+        self.http_client = http_client
+        self.session_id = session_id
+        self.message_id = message_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to interrupt a running command."""
+        response = self.http_client.post(
+            f"interact/shell/sessions/{self.session_id}/messages/{self.message_id}/interrupt-command",
+            json_data={}
+        )
+        
+        return response
+
+
+class CloseSessionCommand(Command[Dict[str, Any]]):
+    """Command to close a shell session."""
+    
+    def __init__(self, http_client: HTTPClient, session_id: str):
+        self.http_client = http_client
+        self.session_id = session_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command to close a shell session."""
+        response = self.http_client.post(
+            f"interact/shell/sessions/{self.session_id}/close",
+            json_data={}
+        )
+        
+        return response 

binalyze_air/commands/investigation_hub.py

@@ -0,0 +1,315 @@
+"""
+Investigation Hub commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any, List
+
+from ..base import Command
+from ..models.investigation_hub import (
+    Investigation, UpdateInvestigationRequest, FlagEvidenceRequest,
+    AddNoteRequest, CreateCommentRequest, InvestigationComment,
+    MarkActivityAsReadRequest, CreateAdvancedFilterRequest,
+    UpdateAdvancedFilterRequest, AdvancedFilter, ExportRequest
+)
+from ..http_client import HTTPClient
+
+
+class UpdateInvestigationCommand(Command[Investigation]):
+    """Command to update an investigation."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str, 
+                 request: UpdateInvestigationRequest):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+        self.request = request
+    
+    def execute(self) -> Investigation:
+        """Execute the command."""
+        response = self.http_client.put(
+            f"investigation-hub/investigations/{self.investigation_id}",
+            json_data=self.request.model_dump(by_alias=True, exclude_none=True)
+        )
+        return Investigation(**response["result"])
+
+
+class DeleteInvestigationCommand(Command[Dict[str, Any]]):
+    """Command to delete an investigation."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command."""
+        response = self.http_client.delete(f"investigation-hub/investigations/{self.investigation_id}")
+        return response
+
+
+class FlagEvidenceCommand(Command[Dict[str, Any]]):
+    """Command to flag evidence records."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str, 
+                 request: FlagEvidenceRequest):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+        self.request = request
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command."""
+        response = self.http_client.post(
+            f"investigation-hub/investigations/{self.investigation_id}/section/flag",
+            json_data=self.request.model_dump(by_alias=True, exclude_none=True)
+        )
+        return response
+
+
+class UnflagEvidenceCommand(Command[Dict[str, Any]]):
+    """Command to unflag evidence records."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str, 
+                 records: List[Dict[str, Any]], section: str):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+        self.records = records
+        self.section = section
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command."""
+        payload = {
+            "records": self.records,
+            "section": self.section
+        }
+        response = self.http_client.delete(
+            f"investigation-hub/investigations/{self.investigation_id}/section/flag",
+            json_data=payload
+        )
+        return response
+
+
+class AddNoteToEvidenceCommand(Command[Dict[str, Any]]):
+    """Command to add a note to evidence records."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str, 
+                 request: AddNoteRequest):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+        self.request = request
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command."""
+        response = self.http_client.put(
+            f"investigation-hub/investigations/{self.investigation_id}/notes",
+            json_data=self.request.model_dump(by_alias=True, exclude_none=True)
+        )
+        return response
+
+
+class CreateCommentCommand(Command[InvestigationComment]):
+    """Command to create a comment in an investigation."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str, 
+                 request: CreateCommentRequest):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+        self.request = request
+    
+    def execute(self) -> InvestigationComment:
+        """Execute the command."""
+        response = self.http_client.post(
+            f"investigation-hub/investigations/{self.investigation_id}/comments",
+            json_data=self.request.model_dump(by_alias=True, exclude_none=True)
+        )
+        return InvestigationComment(**response["result"])
+
+
+class UpdateCommentCommand(Command[InvestigationComment]):
+    """Command to update a comment in an investigation."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str, 
+                 comment_id: str, content: str):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+        self.comment_id = comment_id
+        self.content = content
+    
+    def execute(self) -> InvestigationComment:
+        """Execute the command."""
+        payload = {"content": self.content}
+        response = self.http_client.put(
+            f"investigation-hub/investigations/{self.investigation_id}/comments/{self.comment_id}",
+            json_data=payload
+        )
+        return InvestigationComment(**response["result"])
+
+
+class DeleteCommentCommand(Command[Dict[str, Any]]):
+    """Command to delete a comment from an investigation."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str, comment_id: str):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+        self.comment_id = comment_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command."""
+        response = self.http_client.delete(
+            f"investigation-hub/investigations/{self.investigation_id}/comments/{self.comment_id}"
+        )
+        return response
+
+
+class MarkActivitiesAsReadCommand(Command[Dict[str, Any]]):
+    """Command to mark activities as read."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str, 
+                 request: MarkActivityAsReadRequest):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+        self.request = request
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command."""
+        response = self.http_client.post(
+            f"investigation-hub/investigations/{self.investigation_id}/activities/mark-as-read",
+            json_data=self.request.model_dump(by_alias=True, exclude_none=True)
+        )
+        return response
+
+
+class CreateAdvancedFilterCommand(Command[AdvancedFilter]):
+    """Command to create an advanced filter."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str, 
+                 request: CreateAdvancedFilterRequest):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+        self.request = request
+    
+    def execute(self) -> AdvancedFilter:
+        """Execute the command."""
+        response = self.http_client.post(
+            f"investigation-hub/advanced-filters",
+            json_data=self.request.model_dump(by_alias=True, exclude_none=True)
+        )
+        return AdvancedFilter(**response["result"])
+
+
+class UpdateAdvancedFilterCommand(Command[AdvancedFilter]):
+    """Command to update an advanced filter."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str, 
+                 filter_id: int, request: UpdateAdvancedFilterRequest):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+        self.filter_id = filter_id
+        self.request = request
+    
+    def execute(self) -> AdvancedFilter:
+        """Execute the command."""
+        response = self.http_client.put(
+            f"investigation-hub/advanced-filters/{self.filter_id}",
+            json_data=self.request.model_dump(by_alias=True, exclude_none=True)
+        )
+        return AdvancedFilter(**response["result"])
+
+
+class DeleteAdvancedFilterCommand(Command[Dict[str, Any]]):
+    """Command to delete an advanced filter."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str, filter_id: int):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+        self.filter_id = filter_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command."""
+        response = self.http_client.delete(
+            f"investigation-hub/advanced-filters/{self.filter_id}"
+        )
+        return response
+
+
+class ExportEvidenceCommand(Command[Dict[str, Any]]):
+    """Command to export evidence data."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str, 
+                 request: ExportRequest):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+        self.request = request
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command."""
+        response = self.http_client.post(
+            f"investigation-hub/investigations/{self.investigation_id}/export-flags",
+            json_data=self.request.model_dump(by_alias=True, exclude_none=True)
+        )
+        return response
+
+
+class GenerateReportCommand(Command[Dict[str, Any]]):
+    """Command to generate an investigation report."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str, 
+                 report_type: str = "comprehensive", include_evidence: bool = True):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+        self.report_type = report_type
+        self.include_evidence = include_evidence
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command."""
+        payload = {
+            "reportType": self.report_type,
+            "includeEvidence": self.include_evidence
+        }
+        response = self.http_client.post(
+            f"investigation-hub/investigations/{self.investigation_id}/generate-report",
+            json_data=payload
+        )
+        return response
+
+
+class RefreshInvestigationCommand(Command[Investigation]):
+    """Command to refresh/rebuild an investigation."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+    
+    def execute(self) -> Investigation:
+        """Execute the command."""
+        response = self.http_client.post(
+            f"investigation-hub/investigations/{self.investigation_id}/refresh"
+        )
+        return Investigation(**response["result"])
+
+
+class ArchiveInvestigationCommand(Command[Dict[str, Any]]):
+    """Command to archive an investigation."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the command."""
+        response = self.http_client.post(
+            f"investigation-hub/investigations/{self.investigation_id}/archive"
+        )
+        return response
+
+
+class RestoreInvestigationCommand(Command[Investigation]):
+    """Command to restore an archived investigation."""
+    
+    def __init__(self, http_client: HTTPClient, investigation_id: str):
+        self.http_client = http_client
+        self.investigation_id = investigation_id
+    
+    def execute(self) -> Investigation:
+        """Execute the command."""
+        response = self.http_client.post(
+            f"investigation-hub/investigations/{self.investigation_id}/restore"
+        )
+        return Investigation(**response["result"])