strix-agent 0.4.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

strix/tools/notes/notes_actions_schema.xml

@@ -1,10 +1,9 @@
 <tools>
   <tool name="create_note">
-    <description>Create a personal note for TODOs, side notes, plans, and organizational purposes during
-  the scan.</description>
-    <details>Use this tool for quick reminders, action items, planning thoughts, and organizational notes
-  rather than formal vulnerability reports or detailed findings. This is your personal notepad
-  for keeping track of tasks, ideas, and things to remember or follow up on.</details>
+    <description>Create a personal note for observations, findings, and research during the scan.</description>
+    <details>Use this tool for documenting discoveries, observations, methodology notes, and questions.
+  This is your personal notepad for recording information you want to remember or reference later.
+  For tracking actionable tasks, use the todo tool instead.</details>
     <parameters>
       <parameter name="title" type="string" required="true">
         <description>Title of the note</description>
@@ -13,49 +12,66 @@
         <description>Content of the note</description>
       </parameter>
       <parameter name="category" type="string" required="false">
-        <description>Category to organize the note (default: "general", "findings", "methodology", "todo", "questions", "plan")</description>
+        <description>Category to organize the note (default: "general", "findings", "methodology", "questions", "plan")</description>
       </parameter>
       <parameter name="tags" type="string" required="false">
         <description>Tags for categorization</description>
       </parameter>
-      <parameter name="priority" type="string" required="false">
-        <description>Priority level of the note ("low", "normal", "high", "urgent")</description>
-      </parameter>
     </parameters>
     <returns type="Dict[str, Any]">
       <description>Response containing: - note_id: ID of the created note - success: Whether the note was created successfully</description>
     </returns>
     <examples>
-  # Create a TODO reminder
+  # Document an interesting finding
   <function=create_note>
-  <parameter=title>TODO: Check SSL Certificate Details</parameter>
-  <parameter=content>Remember to verify SSL certificate validity and check for weak ciphers
-               on the HTTPS service discovered on port 443. Also check for certificate
-               transparency logs.</parameter>
-  <parameter=category>todo</parameter>
-  <parameter=tags>["ssl", "certificate", "followup"]</parameter>
-  <parameter=priority>normal</parameter>
-  </function>
+  <parameter=title>Authentication Bypass Findings</parameter>
+  <parameter=content>Discovered multiple authentication bypass vectors in the login system:
 
-  # Planning note
-  <function=create_note>
-  <parameter=title>Scan Strategy Planning</parameter>
-  <parameter=content>Plan for next phase: 1) Complete subdomain enumeration 2) Test discovered
-               web apps for OWASP Top 10 3) Check database services for default creds
-               4) Review any custom applications for business logic flaws</parameter>
-  <parameter=category>plan</parameter>
-  <parameter=tags>["planning", "strategy", "next_steps"]</parameter>
+1. SQL Injection in username field
+   - Payload: admin'--
+   - Result: Full authentication bypass
+   - Endpoint: POST /api/v1/auth/login
+
+2. JWT Token Weakness
+   - Algorithm confusion attack possible (RS256 -> HS256)
+   - Token expiration is 24 hours but no refresh rotation
+   - Token stored in localStorage (XSS risk)
+
+3. Password Reset Flow
+   - Reset tokens are only 6 digits (brute-forceable)
+   - No rate limiting on reset attempts
+   - Token valid for 48 hours
+
+Next Steps:
+- Extract full database via SQL injection
+- Test JWT manipulation attacks
+- Attempt password reset brute force</parameter>
+  <parameter=category>findings</parameter>
+  <parameter=tags>["auth", "sqli", "jwt", "critical"]</parameter>
   </function>
 
-  # Side note for later investigation
+  # Methodology note
   <function=create_note>
-  <parameter=title>Interesting Directory Found</parameter>
-  <parameter=content>Found /backup/ directory that might contain sensitive files. Low priority
-               for now but worth checking if time permits. Directory listing seems
-               disabled.</parameter>
-  <parameter=category>findings</parameter>
-  <parameter=tags>["directory", "backup", "low_priority"]</parameter>
-  <parameter=priority>low</parameter>
+  <parameter=title>API Endpoint Mapping Complete</parameter>
+  <parameter=content>Completed comprehensive API enumeration using multiple techniques:
+
+Discovered Endpoints:
+- /api/v1/auth/* - Authentication endpoints (login, register, reset)
+- /api/v1/users/* - User management (profile, settings, admin)
+- /api/v1/orders/* - Order management (IDOR vulnerability confirmed)
+- /api/v1/admin/* - Admin panel (403 but may be bypassable)
+- /api/internal/* - Internal APIs (should not be exposed)
+
+Methods Used:
+- Analyzed JavaScript bundles for API calls
+- Bruteforced common paths with ffuf
+- Reviewed OpenAPI/Swagger documentation at /api/docs
+- Monitored traffic during normal application usage
+
+Priority Targets:
+The /api/internal/* endpoints are high priority as they appear to lack authentication checks based on error message differences.</parameter>
+  <parameter=category>methodology</parameter>
+  <parameter=tags>["api", "enumeration", "recon"]</parameter>
   </function>
     </examples>
   </tool>
@@ -84,9 +100,6 @@
       <parameter name="tags" type="string" required="false">
         <description>Filter by tags (returns notes with any of these tags)</description>
       </parameter>
-      <parameter name="priority" type="string" required="false">
-        <description>Filter by priority level</description>
-      </parameter>
       <parameter name="search" type="string" required="false">
         <description>Search query to find in note titles and content</description>
       </parameter>
@@ -100,11 +113,6 @@
   <parameter=category>findings</parameter>
   </function>
 
-  # List high priority items
-  <function=list_notes>
-  <parameter=priority>high</parameter>
-  </function>
-
   # Search for SQL injection related notes
   <function=list_notes>
   <parameter=search>SQL injection</parameter>
@@ -132,9 +140,6 @@
       <parameter name="tags" type="string" required="false">
         <description>New tags for the note</description>
       </parameter>
-      <parameter name="priority" type="string" required="false">
-        <description>New priority level</description>
-      </parameter>
     </parameters>
     <returns type="Dict[str, Any]">
       <description>Response containing: - success: Whether the note was updated successfully</description>
@@ -143,7 +148,6 @@
   <function=update_note>
   <parameter=note_id>note_123</parameter>
   <parameter=content>Updated content with new findings...</parameter>
-  <parameter=priority>urgent</parameter>
   </function>
     </examples>
   </tool>

strix/tools/proxy/proxy_actions.py

@@ -2,8 +2,6 @@ from typing import Any, Literal
 
 from strix.tools.registry import register_tool
 
-from .proxy_manager import get_proxy_manager
-
 
 RequestPart = Literal["request", "response"]
 
@@ -27,6 +25,8 @@ def list_requests(
     sort_order: Literal["asc", "desc"] = "desc",
     scope_id: str | None = None,
 ) -> dict[str, Any]:
+    from .proxy_manager import get_proxy_manager
+
     manager = get_proxy_manager()
     return manager.list_requests(
         httpql_filter, start_page, end_page, page_size, sort_by, sort_order, scope_id
@@ -41,6 +41,8 @@ def view_request(
     page: int = 1,
     page_size: int = 50,
 ) -> dict[str, Any]:
+    from .proxy_manager import get_proxy_manager
+
     manager = get_proxy_manager()
     return manager.view_request(request_id, part, search_pattern, page, page_size)
 
@@ -53,6 +55,8 @@ def send_request(
     body: str = "",
     timeout: int = 30,
 ) -> dict[str, Any]:
+    from .proxy_manager import get_proxy_manager
+
     if headers is None:
         headers = {}
     manager = get_proxy_manager()
@@ -64,6 +68,8 @@ def repeat_request(
     request_id: str,
     modifications: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
+    from .proxy_manager import get_proxy_manager
+
     if modifications is None:
         modifications = {}
     manager = get_proxy_manager()
@@ -78,6 +84,8 @@ def scope_rules(
     scope_id: str | None = None,
     scope_name: str | None = None,
 ) -> dict[str, Any]:
+    from .proxy_manager import get_proxy_manager
+
     manager = get_proxy_manager()
     return manager.scope_rules(action, allowlist, denylist, scope_id, scope_name)
 
@@ -89,6 +97,8 @@ def list_sitemap(
     depth: Literal["DIRECT", "ALL"] = "DIRECT",
     page: int = 1,
 ) -> dict[str, Any]:
+    from .proxy_manager import get_proxy_manager
+
     manager = get_proxy_manager()
     return manager.list_sitemap(scope_id, parent_id, depth, page)
 
@@ -97,5 +107,7 @@ def list_sitemap(
 def view_sitemap_entry(
     entry_id: str,
 ) -> dict[str, Any]:
+    from .proxy_manager import get_proxy_manager
+
     manager = get_proxy_manager()
     return manager.view_sitemap_entry(entry_id)

strix/tools/proxy/proxy_actions_schema.xml

@@ -1,4 +1,3 @@
-<?xml version="1.0" ?>
 <tools>
   <tool name="list_requests">
     <description>List and filter proxy requests using HTTPQL with pagination.</description>

strix/tools/proxy/proxy_manager.py

@@ -16,17 +16,24 @@ if TYPE_CHECKING:
     from collections.abc import Callable
 
 
+CAIDO_PORT = 48080  # Fixed port inside container
+
+
 class ProxyManager:
     def __init__(self, auth_token: str | None = None):
         host = "127.0.0.1"
-        port = os.getenv("CAIDO_PORT", "56789")
-        self.base_url = f"http://{host}:{port}/graphql"
-        self.proxies = {"http": f"http://{host}:{port}", "https": f"http://{host}:{port}"}
+        self.base_url = f"http://{host}:{CAIDO_PORT}/graphql"
+        self.proxies = {
+            "http": f"http://{host}:{CAIDO_PORT}",
+            "https": f"http://{host}:{CAIDO_PORT}",
+        }
         self.auth_token = auth_token or os.getenv("CAIDO_API_TOKEN")
-        self.transport = RequestsHTTPTransport(
+
+    def _get_client(self) -> Client:
+        transport = RequestsHTTPTransport(
             url=self.base_url, headers={"Authorization": f"Bearer {self.auth_token}"}
         )
-        self.client = Client(transport=self.transport, fetch_schema_from_transport=False)
+        return Client(transport=transport, fetch_schema_from_transport=False)
 
     def list_requests(
         self,
@@ -85,7 +92,7 @@ class ProxyManager:
         }
 
         try:
-            result = self.client.execute(query, variable_values=variables)
+            result = self._get_client().execute(query, variable_values=variables)
             data = result.get("requestsByOffset", {})
             nodes = [edge["node"] for edge in data.get("edges", [])]
 
@@ -132,7 +139,9 @@ class ProxyManager:
             return {"error": f"Invalid part '{part}'. Use 'request' or 'response'"}
 
         try:
-            result = self.client.execute(gql(queries[part]), variable_values={"id": request_id})
+            result = self._get_client().execute(
+                gql(queries[part]), variable_values={"id": request_id}
+            )
             request_data = result.get("request", {})
 
             if not request_data:
@@ -430,7 +439,9 @@ class ProxyManager:
             }
 
     def _handle_scope_list(self) -> dict[str, Any]:
-        result = self.client.execute(gql("query { scopes { id name allowlist denylist indexed } }"))
+        result = self._get_client().execute(
+            gql("query { scopes { id name allowlist denylist indexed } }")
+        )
         scopes = result.get("scopes", [])
         return {"scopes": scopes, "count": len(scopes)}
 
@@ -438,7 +449,7 @@ class ProxyManager:
         if not scope_id:
             return self._handle_scope_list()
 
-        result = self.client.execute(
+        result = self._get_client().execute(
             gql(
                 "query GetScope($id: ID!) { scope(id: $id) { id name allowlist denylist indexed } }"
             ),
@@ -467,7 +478,7 @@ class ProxyManager:
             }
         """)
 
-        result = self.client.execute(
+        result = self._get_client().execute(
             mutation,
             variable_values={
                 "input": {
@@ -507,7 +518,7 @@ class ProxyManager:
             }
         """)
 
-        result = self.client.execute(
+        result = self._get_client().execute(
             mutation,
             variable_values={
                 "id": scope_id,
@@ -530,7 +541,7 @@ class ProxyManager:
         if not scope_id:
             return {"error": "scope_id required for delete"}
 
-        result = self.client.execute(
+        result = self._get_client().execute(
             gql("mutation DeleteScope($id: ID!) { deleteScope(id: $id) { deletedId } }"),
             variable_values={"id": scope_id},
         )
@@ -607,7 +618,7 @@ class ProxyManager:
                         }
                     }
                 """)
-                result = self.client.execute(
+                result = self._get_client().execute(
                     query, variable_values={"parentId": parent_id, "depth": depth}
                 )
                 data = result.get("sitemapDescendantEntries", {})
@@ -624,7 +635,7 @@ class ProxyManager:
                         }
                     }
                 """)
-                result = self.client.execute(query, variable_values={"scopeId": scope_id})
+                result = self._get_client().execute(query, variable_values={"scopeId": scope_id})
                 data = result.get("sitemapRootEntries", {})
 
             all_nodes = [edge["node"] for edge in data.get("edges", [])]
@@ -731,7 +742,7 @@ class ProxyManager:
                 }
             """)
 
-            result = self.client.execute(query, variable_values={"id": entry_id})
+            result = self._get_client().execute(query, variable_values={"id": entry_id})
             entry = result.get("sitemapEntry")
 
             if not entry:
@@ -780,6 +791,7 @@ _PROXY_MANAGER: ProxyManager | None = None
 
 
 def get_proxy_manager() -> ProxyManager:
+    global _PROXY_MANAGER  # noqa: PLW0603
     if _PROXY_MANAGER is None:
-        return ProxyManager()
+        _PROXY_MANAGER = ProxyManager()
     return _PROXY_MANAGER

strix/tools/python/python_actions.py

@@ -2,8 +2,6 @@ from typing import Any, Literal
 
 from strix.tools.registry import register_tool
 
-from .python_manager import get_python_session_manager
-
 
 PythonAction = Literal["new_session", "execute", "close", "list_sessions"]
 
@@ -15,6 +13,8 @@ def python_action(
     timeout: int = 30,
     session_id: str | None = None,
 ) -> dict[str, Any]:
+    from .python_manager import get_python_session_manager
+
     def _validate_code(action_name: str, code: str | None) -> None:
         if not code:
             raise ValueError(f"code parameter is required for {action_name} action")

strix/tools/python/python_actions_schema.xml

@@ -1,4 +1,3 @@
-<?xml version="1.0" encoding="UTF-8"?>
 <tools>
   <tool name="python_action">
     <description>Perform Python actions using persistent interpreter sessions for cybersecurity tasks.</description>
@@ -55,6 +54,7 @@
          - Print statements and stdout are captured
          - Variables persist between executions in the same session
          - Imports, function definitions, etc. persist in the session
+         - IMPORTANT (multiline): Put real line breaks in your code. Do NOT emit literal "\n" sequences — use actual newlines.
          - IPython magic commands are fully supported (%pip, %time, %whos, %%writefile, etc.)
          - Line magics (%) and cell magics (%%) work as expected
       6. CLOSE: Terminates the session completely and frees memory
@@ -73,6 +73,14 @@
       print("Security analysis session started")</parameter>
       </function>
 
+      <function=python_action>
+      <parameter=action>execute</parameter>
+      <parameter=code>import requests
+url = "https://example.com"
+resp = requests.get(url, timeout=10)
+print(resp.status_code)</parameter>
+      </function>
+
       # Analyze security data in the default session
       <function=python_action>
       <parameter=action>execute</parameter>

strix/tools/python/python_instance.py

@@ -1,5 +1,4 @@
 import io
-import signal
 import sys
 import threading
 from typing import Any
@@ -57,28 +56,6 @@ class PythonInstance:
             }
         return None
 
-    def _setup_execution_environment(self, timeout: int) -> tuple[Any, io.StringIO, io.StringIO]:
-        stdout_capture = io.StringIO()
-        stderr_capture = io.StringIO()
-
-        def timeout_handler(signum: int, frame: Any) -> None:
-            raise TimeoutError(f"Code execution timed out after {timeout} seconds")
-
-        old_handler = signal.signal(signal.SIGALRM, timeout_handler)
-        signal.alarm(timeout)
-
-        sys.stdout = stdout_capture
-        sys.stderr = stderr_capture
-
-        return old_handler, stdout_capture, stderr_capture
-
-    def _cleanup_execution_environment(
-        self, old_handler: Any, old_stdout: Any, old_stderr: Any
-    ) -> None:
-        signal.signal(signal.SIGALRM, old_handler)
-        sys.stdout = old_stdout
-        sys.stderr = old_stderr
-
     def _truncate_output(self, content: str, max_length: int, suffix: str) -> str:
         if len(content) > max_length:
             return content[:max_length] + suffix
@@ -142,27 +119,52 @@ class PythonInstance:
             return session_error
 
         with self._execution_lock:
-            old_stdout, old_stderr = sys.stdout, sys.stderr
+            result_container: dict[str, Any] = {}
+            stdout_capture = io.StringIO()
+            stderr_capture = io.StringIO()
+            cancelled = threading.Event()
 
-            try:
-                old_handler, stdout_capture, stderr_capture = self._setup_execution_environment(
-                    timeout
-                )
+            old_stdout, old_stderr = sys.stdout, sys.stderr
 
+            def _run_code() -> None:
                 try:
+                    sys.stdout = stdout_capture
+                    sys.stderr = stderr_capture
                     execution_result = self.shell.run_cell(code, silent=False, store_history=True)
-                    signal.alarm(0)
+                    result_container["execution_result"] = execution_result
+                    result_container["stdout"] = stdout_capture.getvalue()
+                    result_container["stderr"] = stderr_capture.getvalue()
+                except (KeyboardInterrupt, SystemExit) as e:
+                    result_container["error"] = e
+                except Exception as e:  # noqa: BLE001
+                    result_container["error"] = e
+                finally:
+                    if not cancelled.is_set():
+                        sys.stdout = old_stdout
+                        sys.stderr = old_stderr
+
+            exec_thread = threading.Thread(target=_run_code, daemon=True)
+            exec_thread.start()
+            exec_thread.join(timeout=timeout)
+
+            if exec_thread.is_alive():
+                cancelled.set()
+                sys.stdout, sys.stderr = old_stdout, old_stderr
+                return self._handle_execution_error(
+                    TimeoutError(f"Code execution timed out after {timeout} seconds")
+                )
 
-                    return self._format_execution_result(
-                        execution_result, stdout_capture.getvalue(), stderr_capture.getvalue()
-                    )
+            if "error" in result_container:
+                return self._handle_execution_error(result_container["error"])
 
-                except (TimeoutError, KeyboardInterrupt, SystemExit) as e:
-                    signal.alarm(0)
-                    return self._handle_execution_error(e)
+            if "execution_result" in result_container:
+                return self._format_execution_result(
+                    result_container["execution_result"],
+                    result_container.get("stdout", ""),
+                    result_container.get("stderr", ""),
+                )
 
-            finally:
-                self._cleanup_execution_environment(old_handler, old_stdout, old_stderr)
+            return self._handle_execution_error(RuntimeError("Unknown execution error"))
 
     def close(self) -> None:
         self.is_running = False

strix/tools/python/python_manager.py

@@ -1,33 +1,41 @@
 import atexit
 import contextlib
-import signal
-import sys
 import threading
 from typing import Any
 
+from strix.tools.context import get_current_agent_id
+
 from .python_instance import PythonInstance
 
 
 class PythonSessionManager:
     def __init__(self) -> None:
-        self.sessions: dict[str, PythonInstance] = {}
+        self._sessions_by_agent: dict[str, dict[str, PythonInstance]] = {}
         self._lock = threading.Lock()
         self.default_session_id = "default"
 
         self._register_cleanup_handlers()
 
+    def _get_agent_sessions(self) -> dict[str, PythonInstance]:
+        agent_id = get_current_agent_id()
+        with self._lock:
+            if agent_id not in self._sessions_by_agent:
+                self._sessions_by_agent[agent_id] = {}
+            return self._sessions_by_agent[agent_id]
+
     def create_session(
         self, session_id: str | None = None, initial_code: str | None = None, timeout: int = 30
     ) -> dict[str, Any]:
         if session_id is None:
             session_id = self.default_session_id
 
+        sessions = self._get_agent_sessions()
         with self._lock:
-            if session_id in self.sessions:
+            if session_id in sessions:
                 raise ValueError(f"Python session '{session_id}' already exists")
 
             session = PythonInstance(session_id)
-            self.sessions[session_id] = session
+            sessions[session_id] = session
 
             if initial_code:
                 result = session.execute_code(initial_code, timeout)
@@ -51,11 +59,12 @@ class PythonSessionManager:
         if not code:
             raise ValueError("No code provided for execution")
 
+        sessions = self._get_agent_sessions()
         with self._lock:
-            if session_id not in self.sessions:
+            if session_id not in sessions:
                 raise ValueError(f"Python session '{session_id}' not found")
 
-            session = self.sessions[session_id]
+            session = sessions[session_id]
 
         result = session.execute_code(code, timeout)
         result["message"] = f"Code executed in session '{session_id}'"
@@ -65,11 +74,12 @@ class PythonSessionManager:
         if session_id is None:
             session_id = self.default_session_id
 
+        sessions = self._get_agent_sessions()
         with self._lock:
-            if session_id not in self.sessions:
+            if session_id not in sessions:
                 raise ValueError(f"Python session '{session_id}' not found")
 
-            session = self.sessions.pop(session_id)
+            session = sessions.pop(session_id)
 
         session.close()
         return {
@@ -79,9 +89,10 @@ class PythonSessionManager:
         }
 
     def list_sessions(self) -> dict[str, Any]:
+        sessions = self._get_agent_sessions()
         with self._lock:
             session_info = {}
-            for sid, session in self.sessions.items():
+            for sid, session in sessions.items():
                 session_info[sid] = {
                     "is_running": session.is_running,
                     "is_alive": session.is_alive(),
@@ -89,40 +100,41 @@ class PythonSessionManager:
 
         return {"sessions": session_info, "total_count": len(session_info)}
 
+    def cleanup_agent(self, agent_id: str) -> None:
+        with self._lock:
+            sessions = self._sessions_by_agent.pop(agent_id, {})
+
+        for session in sessions.values():
+            with contextlib.suppress(Exception):
+                session.close()
+
     def cleanup_dead_sessions(self) -> None:
         with self._lock:
-            dead_sessions = []
-            for sid, session in self.sessions.items():
-                if not session.is_alive():
-                    dead_sessions.append(sid)
+            for sessions in self._sessions_by_agent.values():
+                dead_sessions = []
+                for sid, session in sessions.items():
+                    if not session.is_alive():
+                        dead_sessions.append(sid)
 
-            for sid in dead_sessions:
-                session = self.sessions.pop(sid)
-                with contextlib.suppress(Exception):
-                    session.close()
+                for sid in dead_sessions:
+                    session = sessions.pop(sid)
+                    with contextlib.suppress(Exception):
+                        session.close()
 
     def close_all_sessions(self) -> None:
         with self._lock:
-            sessions_to_close = list(self.sessions.values())
-            self.sessions.clear()
+            all_sessions: list[PythonInstance] = []
+            for sessions in self._sessions_by_agent.values():
+                all_sessions.extend(sessions.values())
+            self._sessions_by_agent.clear()
 
-        for session in sessions_to_close:
+        for session in all_sessions:
             with contextlib.suppress(Exception):
                 session.close()
 
     def _register_cleanup_handlers(self) -> None:
         atexit.register(self.close_all_sessions)
 
-        signal.signal(signal.SIGTERM, self._signal_handler)
-        signal.signal(signal.SIGINT, self._signal_handler)
-
-        if hasattr(signal, "SIGHUP"):
-            signal.signal(signal.SIGHUP, self._signal_handler)
-
-    def _signal_handler(self, _signum: int, _frame: Any) -> None:
-        self.close_all_sessions()
-        sys.exit(0)
-
 
 _python_session_manager = PythonSessionManager()