shadowcat 2.0.0__py3-none-any.whl

agent/core/session.py

@@ -0,0 +1,228 @@
+"""Session management for ShadowCat - persistence and state tracking."""
+
+import json
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+
+class SessionStatus(Enum):
+    """Session lifecycle status."""
+
+    RUNNING = "running"
+    PAUSED = "paused"
+    COMPLETED = "completed"
+    ERROR = "error"
+
+
+@dataclass
+class SessionInfo:
+    """Session state - framework agnostic."""
+
+    session_id: str
+    target: str
+    created_at: datetime
+    status: SessionStatus = SessionStatus.RUNNING
+    backend_session_id: str | None = None  # Backend-specific ID (e.g., Claude session)
+    updated_at: datetime | None = None
+    task: str = ""
+    user_instructions: list[str] = field(default_factory=list)
+    flags_found: list[dict[str, str]] = field(default_factory=list)
+    total_cost_usd: float = 0.0
+    model: str = ""
+    last_error: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize session to dictionary for JSON storage."""
+        return {
+            "session_id": self.session_id,
+            "target": self.target,
+            "created_at": self.created_at.isoformat(),
+            "status": self.status.value,
+            "backend_session_id": self.backend_session_id,
+            "updated_at": self.updated_at.isoformat() if self.updated_at else None,
+            "task": self.task,
+            "user_instructions": self.user_instructions,
+            "flags_found": self.flags_found,
+            "total_cost_usd": self.total_cost_usd,
+            "model": self.model,
+            "last_error": self.last_error,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "SessionInfo":
+        """Deserialize session from dictionary."""
+        return cls(
+            session_id=data["session_id"],
+            target=data["target"],
+            created_at=datetime.fromisoformat(data["created_at"]),
+            status=SessionStatus(data["status"]),
+            backend_session_id=data.get("backend_session_id"),
+            updated_at=(
+                datetime.fromisoformat(data["updated_at"]) if data.get("updated_at") else None
+            ),
+            task=data.get("task", ""),
+            user_instructions=data.get("user_instructions", []),
+            flags_found=data.get("flags_found", []),
+            total_cost_usd=data.get("total_cost_usd", 0.0),
+            model=data.get("model", ""),
+            last_error=data.get("last_error"),
+        )
+
+
+class SessionStore:
+    """Simple file-based session persistence."""
+
+    SESSIONS_DIR = Path.home() / ".shadowcat_agent" / "sessions"
+
+    def __init__(self, sessions_dir: Path | None = None):
+        """Initialize session store.
+
+        Args:
+            sessions_dir: Optional custom sessions directory
+        """
+        self._sessions_dir = sessions_dir or self.SESSIONS_DIR
+        self._sessions_dir.mkdir(parents=True, exist_ok=True)
+        self._current: SessionInfo | None = None
+
+    def create(self, target: str, task: str, model: str) -> SessionInfo:
+        """Create a new session.
+
+        Args:
+            target: Target URL/IP/domain
+            task: Task description
+            model: Model name
+
+        Returns:
+            New SessionInfo instance
+        """
+        session = SessionInfo(
+            session_id=str(uuid.uuid4())[:8],
+            target=target,
+            created_at=datetime.now(),
+            task=task,
+            model=model,
+        )
+        self._current = session
+        self.save()
+        return session
+
+    @property
+    def current(self) -> SessionInfo | None:
+        """Get current active session."""
+        return self._current
+
+    def save(self) -> None:
+        """Save current session to disk."""
+        if not self._current:
+            return
+        self._current.updated_at = datetime.now()
+        path = self._sessions_dir / f"{self._current.session_id}.json"
+        path.write_text(json.dumps(self._current.to_dict(), indent=2))
+
+    def load(self, session_id: str) -> SessionInfo | None:
+        """Load a session by ID.
+
+        Args:
+            session_id: Session ID to load
+
+        Returns:
+            SessionInfo if found, None otherwise
+        """
+        path = self._sessions_dir / f"{session_id}.json"
+        if not path.exists():
+            return None
+        try:
+            self._current = SessionInfo.from_dict(json.loads(path.read_text()))
+            return self._current
+        except (json.JSONDecodeError, KeyError, ValueError):
+            return None
+
+    def list_sessions(self, target: str | None = None) -> list[SessionInfo]:
+        """List all sessions, optionally filtered by target.
+
+        Args:
+            target: Optional target filter
+
+        Returns:
+            List of SessionInfo, sorted by creation date (newest first)
+        """
+        sessions = []
+        for path in self._sessions_dir.glob("*.json"):
+            try:
+                session = SessionInfo.from_dict(json.loads(path.read_text()))
+                if target is None or session.target == target:
+                    sessions.append(session)
+            except (json.JSONDecodeError, KeyError, ValueError):
+                continue
+        return sorted(sessions, key=lambda s: s.created_at, reverse=True)
+
+    def get_latest(self, target: str | None = None) -> SessionInfo | None:
+        """Get the most recent session.
+
+        Args:
+            target: Optional target filter
+
+        Returns:
+            Most recent SessionInfo if any exist
+        """
+        sessions = self.list_sessions(target)
+        return sessions[0] if sessions else None
+
+    def delete(self, session_id: str) -> bool:
+        """Delete a session by ID.
+
+        Args:
+            session_id: Session ID to delete
+
+        Returns:
+            True if deleted, False if not found
+        """
+        path = self._sessions_dir / f"{session_id}.json"
+        if path.exists():
+            path.unlink()
+            if self._current and self._current.session_id == session_id:
+                self._current = None
+            return True
+        return False
+
+    # Convenience methods for updating current session
+
+    def update_status(self, status: SessionStatus) -> None:
+        """Update current session status."""
+        if self._current:
+            self._current.status = status
+            self.save()
+
+    def add_instruction(self, instruction: str) -> None:
+        """Add a user instruction to current session."""
+        if self._current:
+            self._current.user_instructions.append(instruction)
+            self.save()
+
+    def add_flag(self, flag: str, context: str) -> None:
+        """Add a found flag to current session."""
+        if self._current:
+            self._current.flags_found.append({"flag": flag, "context": context})
+            self.save()
+
+    def set_backend_session_id(self, backend_id: str) -> None:
+        """Set the backend-specific session ID."""
+        if self._current:
+            self._current.backend_session_id = backend_id
+            self.save()
+
+    def add_cost(self, cost: float) -> None:
+        """Add to total cost."""
+        if self._current:
+            self._current.total_cost_usd += cost
+            self.save()
+
+    def set_error(self, error: str) -> None:
+        """Set last error."""
+        if self._current:
+            self._current.last_error = error
+            self.save()

agent/core/tracer.py

@@ -0,0 +1,137 @@
+"""Activity tracer for tracking agent actions and tool executions."""
+
+import threading
+from collections.abc import Callable
+from datetime import datetime
+from typing import Any
+
+
+class Tracer:
+    """Lightweight tracer for tracking agent activity."""
+
+    def __init__(self) -> None:
+        """Initialize the tracer."""
+        self._lock = threading.Lock()
+        self._activities: list[dict[str, Any]] = []
+        self._on_activity_callback: Callable[[dict[str, Any]], None] | None = None
+
+    def set_activity_callback(self, callback: Callable[[dict[str, Any]], None]) -> None:
+        """Set callback function to be called when new activity is tracked."""
+        self._on_activity_callback = callback
+
+    def track_message(
+        self,
+        message: str,
+        message_type: str = "info",
+        timestamp: datetime | None = None,
+    ) -> None:
+        """Track a simple message."""
+        if timestamp is None:
+            timestamp = datetime.now()
+
+        activity = {
+            "type": "message",
+            "message": message,
+            "message_type": message_type,
+            "timestamp": timestamp,
+        }
+
+        with self._lock:
+            self._activities.append(activity)
+
+        if self._on_activity_callback:
+            self._on_activity_callback(activity)
+
+    def track_tool_start(
+        self,
+        tool_name: str,
+        args: dict[str, Any],
+        timestamp: datetime | None = None,
+    ) -> int:
+        """Track the start of a tool execution. Returns activity ID."""
+        if timestamp is None:
+            timestamp = datetime.now()
+
+        activity = {
+            "type": "tool",
+            "tool_name": tool_name,
+            "args": args,
+            "status": "running",
+            "result": None,
+            "timestamp": timestamp,
+        }
+
+        with self._lock:
+            activity_id = len(self._activities)
+            self._activities.append(activity)
+
+        if self._on_activity_callback:
+            self._on_activity_callback(activity)
+
+        return activity_id
+
+    def track_tool_complete(
+        self,
+        activity_id: int,
+        result: Any = None,
+        status: str = "completed",
+    ) -> None:
+        """Mark a tool execution as complete."""
+        with self._lock:
+            if 0 <= activity_id < len(self._activities):
+                activity = self._activities[activity_id]
+                activity["status"] = status
+                activity["result"] = result
+
+                if self._on_activity_callback:
+                    self._on_activity_callback(activity)
+
+    def track_agent_status(
+        self,
+        status: str,
+        details: str | None = None,
+    ) -> None:
+        """Track agent status change."""
+        message = f"Agent status: {status}"
+        if details:
+            message = f"{message} - {details}"
+
+        self.track_message(message, message_type="info")
+
+    def get_recent_activities(self, count: int = 50) -> list[dict[str, Any]]:
+        """Get the most recent activities."""
+        with self._lock:
+            return self._activities[-count:] if self._activities else []
+
+    def get_all_activities(self) -> list[dict[str, Any]]:
+        """Get all tracked activities."""
+        with self._lock:
+            return self._activities.copy()
+
+    def clear(self) -> None:
+        """Clear all tracked activities."""
+        with self._lock:
+            self._activities.clear()
+
+
+# Global tracer instance
+_global_tracer: Tracer | None = None
+_tracer_lock = threading.Lock()
+
+
+def get_global_tracer() -> Tracer:
+    """Get or create the global tracer instance."""
+    global _global_tracer
+
+    if _global_tracer is None:
+        with _tracer_lock:
+            if _global_tracer is None:
+                _global_tracer = Tracer()
+
+    return _global_tracer
+
+
+def set_global_tracer(tracer: Tracer) -> None:
+    """Set a custom global tracer."""
+    global _global_tracer
+    _global_tracer = tracer

agent/interface/components/activity_feed.py

@@ -0,0 +1,202 @@
+"""Activity feed component for displaying real-time agent updates."""
+
+from collections.abc import Iterator
+from datetime import datetime
+from typing import Any
+
+from rich.markup import escape as rich_escape
+from textual.containers import VerticalScroll
+from textual.widgets import Static
+
+
+def escape_markup(text: str) -> str:
+    """Escape Rich markup characters."""
+    return str(rich_escape(text))
+
+
+class ActivityFeed(VerticalScroll):
+    """Scrollable activity feed showing agent actions in real-time."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Initialize activity feed."""
+        super().__init__(*args, **kwargs)
+        self._content_widget: Static | None = None
+        self._activities: list[dict[str, Any]] = []
+
+    def compose(self) -> Iterator[Static]:
+        """Create the feed content area."""
+        content = Static("", id="activity_content")
+        self._content_widget = content
+        yield content
+
+    def add_message(
+        self, message: str, message_type: str = "info", timestamp: datetime | None = None
+    ) -> None:
+        """Add a simple text message to the feed."""
+        if timestamp is None:
+            timestamp = datetime.now()
+
+        activity = {
+            "type": "message",
+            "message": message,
+            "message_type": message_type,
+            "timestamp": timestamp,
+        }
+        self._activities.append(activity)
+        self._render_activities()
+
+    def add_tool_execution(
+        self,
+        tool_name: str,
+        args: dict[str, Any],
+        status: str = "running",
+        result: Any = None,
+        timestamp: datetime | None = None,
+    ) -> None:
+        """Add a tool execution block to the feed."""
+        if timestamp is None:
+            timestamp = datetime.now()
+
+        activity = {
+            "type": "tool",
+            "tool_name": tool_name,
+            "args": args,
+            "status": status,
+            "result": result,
+            "timestamp": timestamp,
+        }
+        self._activities.append(activity)
+        self._render_activities()
+
+    def update_last_tool_status(self, status: str, result: Any = None) -> None:
+        """Update the status of the most recent tool execution."""
+        # Find the last tool activity
+        for activity in reversed(self._activities):
+            if activity["type"] == "tool":
+                activity["status"] = status
+                if result is not None:
+                    activity["result"] = result
+                break
+
+        self._render_activities()
+
+    def clear(self) -> None:
+        """Clear all activities from the feed."""
+        self._activities.clear()
+        if self._content_widget:
+            self._content_widget.update("")
+
+    def _render_activities(self) -> None:
+        """Render all activities to the content widget."""
+        if not self._content_widget:
+            return
+
+        if not self._activities:
+            placeholder = (
+                "\n\n[dim italic]Waiting for agent to start...[/]\n\n"
+                "[dim]The activity feed will show real-time updates here.[/]"
+            )
+            self._content_widget.update(placeholder)
+            self._content_widget.set_classes("placeholder")
+            return
+
+        lines = []
+        for activity in self._activities:
+            if activity["type"] == "message":
+                lines.append(self._render_message(activity))
+            elif activity["type"] == "tool":
+                lines.append(self._render_tool(activity))
+
+        content = "\n\n".join(lines)
+        self._content_widget.update(content)
+        self._content_widget.remove_class("placeholder")
+
+        # Auto-scroll to bottom
+        self.call_later(self.scroll_end, animate=False)
+
+    def _render_message(self, activity: dict[str, Any]) -> str:
+        """Render a simple message activity."""
+        timestamp = activity["timestamp"].strftime("%H:%M:%S")
+        message = escape_markup(activity["message"])
+        message_type = activity["message_type"]
+
+        # Type-specific styling
+        if message_type == "success":
+            icon = "[#10b981]✓[/]"
+            style = "activity-status-success"
+        elif message_type == "error":
+            icon = "[#ef4444]✗[/]"
+            style = "activity-status-error"
+        elif message_type == "warning":
+            icon = "[#f59e0b]⚠[/]"
+            style = ""
+        else:
+            icon = "[#6366f1]●[/]"
+            style = "activity-status-active"
+
+        return f"[dim]{timestamp}[/] {icon} [{style}]{message}[/]" if style else f"{message}"
+
+    def _render_tool(self, activity: dict[str, Any]) -> str:
+        """Render a tool execution block."""
+        timestamp = activity["timestamp"].strftime("%H:%M:%S")
+        tool_name = activity["tool_name"]
+        args = activity["args"]
+        status = activity["status"]
+        result = activity["result"]
+
+        # Determine tool type for styling
+        tool_class = self._get_tool_class(tool_name)
+
+        # Status indicator
+        if status == "running":
+            status_icon = "[#f59e0b]●[/] In progress..."
+        elif status == "completed":
+            status_icon = "[#10b981]✓[/] Done"
+        elif status == "failed":
+            status_icon = "[#ef4444]✗[/] Failed"
+        else:
+            status_icon = "[dim]○[/] Unknown"
+
+        # Build the tool block
+        lines = []
+        lines.append(f"[dim]{timestamp}[/]")
+
+        # Tool header
+        header_class = "tool-header" if tool_class else ""
+        lines.append(f"[{header_class}]▍ {escape_markup(tool_name)}[/] {status_icon}")
+
+        # Arguments
+        if args:
+            for key, value in list(args.items())[:3]:  # Show first 3 args
+                value_str = str(value)
+                if len(value_str) > 100:
+                    value_str = value_str[:97] + "..."
+
+                # Special formatting for command
+                if key == "command" and tool_name == "terminal_execute":
+                    lines.append(f"  [#10b981]$ {escape_markup(value_str)}[/]")
+                else:
+                    lines.append(f"  [dim]{key}:[/] {escape_markup(value_str)}")
+
+        # Result (if completed)
+        if status in ("completed", "failed") and result:
+            result_str = str(result)
+            if len(result_str) > 200:
+                result_str = result_str[:197] + "..."
+
+            lines.append(f"  [dim]→[/] {escape_markup(result_str)}")
+
+        content = "\n".join(lines)
+
+        # Wrap in styled container
+        return f"[{tool_class}]{content}[/]"
+
+    def _get_tool_class(self, tool_name: str) -> str:
+        """Get the CSS class for a tool type."""
+        tool_classes = {
+            "terminal_execute": "tool-terminal",
+            "thinking": "tool-thinking",
+            "result": "tool-result",
+            "error": "tool-error",
+        }
+        return tool_classes.get(tool_name, "tool-block")