flowly-code 1.0.0__py3-none-any.whl

flowly_code/agent/tools/shell.py

@@ -0,0 +1,166 @@
+"""Secure shell execution tool with approval system."""
+
+import asyncio
+from typing import Any, Callable, Awaitable
+
+from loguru import logger
+
+from flowly_code.agent.tools.base import Tool
+from flowly_code.exec import (
+    ExecConfig,
+    ExecRequest,
+    ExecResult,
+    ExecApprovalStore,
+    ExecApprovalDecision,
+    analyze_command,
+    execute_command,
+)
+from flowly_code.exec.types import PendingApproval
+
+
+class SecureExecTool(Tool):
+    """
+    Secure shell command execution tool.
+
+    Features:
+    - Security modes: deny, allowlist, full
+    - Ask modes: off, on-miss, always
+    - Command analysis for dangerous patterns
+    - Safe bins (jq, grep, etc.) always allowed
+    - Allowlist with glob pattern matching
+    - Approval system via callback (Telegram)
+    """
+
+    def __init__(
+        self,
+        config: ExecConfig,
+        approval_callback: Callable[[PendingApproval], Awaitable[ExecApprovalDecision | None]] | None = None,
+        working_dir: str | None = None,
+    ):
+        self.config = config
+        self.working_dir = working_dir
+        self._store = ExecApprovalStore()
+        self._store.load()
+
+        if approval_callback:
+            self._store.set_approval_callback(approval_callback)
+
+    @property
+    def name(self) -> str:
+        return "exec"
+
+    @property
+    def description(self) -> str:
+        if not self.config.enabled:
+            return "Execute shell commands. CURRENTLY DISABLED."
+
+        security = self._store.config.security
+        ask = self._store.config.ask
+
+        desc = "Execute a shell command and return its output.\n\n"
+        desc += f"Security: {security}, Ask: {ask}\n"
+
+        if security == "deny":
+            desc += "WARNING: Command execution is currently denied."
+        elif security == "allowlist":
+            desc += "Only allowlisted commands and safe bins (grep, jq, etc.) are permitted.\n"
+            desc += "Other commands require user approval."
+        elif security == "full":
+            desc += "Full access mode - all commands allowed."
+
+        return desc
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": "The shell command to execute"
+                },
+                "working_dir": {
+                    "type": "string",
+                    "description": "Optional working directory for the command"
+                },
+                "timeout": {
+                    "type": "integer",
+                    "description": f"Optional timeout in seconds (default: {self.config.timeout_seconds})"
+                },
+                "background": {
+                    "type": "boolean",
+                    "description": "Run in background and return immediately with PID. Use for long-running processes (servers, tunnels, watchers). Stop later with: exec(command='kill <PID>')"
+                }
+            },
+            "required": ["command"]
+        }
+
+    def set_approval_callback(
+        self,
+        callback: Callable[[PendingApproval], Awaitable[ExecApprovalDecision | None]]
+    ) -> None:
+        """Set the approval callback (for Telegram integration)."""
+        self._store.set_approval_callback(callback)
+
+    async def execute(
+        self,
+        command: str,
+        working_dir: str | None = None,
+        timeout: int | None = None,
+        background: bool = False,
+        session_key: str | None = None,
+        **kwargs: Any
+    ) -> str:
+        """Execute a command with full security checks."""
+
+        # Create request
+        request = ExecRequest(
+            command=command.strip(),
+            cwd=working_dir or self.working_dir,
+            timeout=timeout,
+            session_key=session_key,
+            background=background,
+        )
+
+        # Analyze command first (for logging)
+        analysis = analyze_command(command)
+        logger.info(f"Exec request: {command[:50]}... (safe_bin={analysis.is_safe_bin}, resolved={analysis.resolved_path})")
+
+        # Execute with security checks
+        result = await execute_command(request, self.config, self._store)
+
+        # Format result
+        if result.denied:
+            return f"❌ Command denied: {result.error}"
+
+        if result.pid is not None and background:
+            return f"✅ Background process started (PID: {result.pid}). To stop: exec(command='kill {result.pid}')"
+
+        if result.timed_out:
+            return f"⏰ Command timed out after {timeout or self.config.timeout_seconds} seconds"
+
+        if result.error:
+            return f"❌ Error: {result.error}"
+
+        # Build output
+        output_parts = []
+
+        if result.stdout:
+            output_parts.append(result.stdout)
+
+        if result.stderr:
+            output_parts.append(f"STDERR:\n{result.stderr}")
+
+        if result.exit_code is not None and result.exit_code != 0:
+            output_parts.append(f"\nExit code: {result.exit_code}")
+
+        return "\n".join(output_parts) if output_parts else "(no output)"
+
+    @property
+    def store(self) -> ExecApprovalStore:
+        """Get the approval store for external management."""
+        return self._store
+
+
+# Keep backward compatibility alias
+ExecTool = SecureExecTool

flowly_code/agent/tools/spawn.py

@@ -0,0 +1,65 @@
+"""Spawn tool for creating background subagents."""
+
+from typing import Any, TYPE_CHECKING
+
+from flowly_code.agent.tools.base import Tool
+
+if TYPE_CHECKING:
+    from flowly_code.agent.subagent import SubagentManager
+
+
+class SpawnTool(Tool):
+    """
+    Tool to spawn a subagent for background task execution.
+    
+    The subagent runs asynchronously and announces its result back
+    to the main agent when complete.
+    """
+    
+    def __init__(self, manager: "SubagentManager"):
+        self._manager = manager
+        self._origin_channel = "cli"
+        self._origin_chat_id = "direct"
+    
+    def set_context(self, channel: str, chat_id: str) -> None:
+        """Set the origin context for subagent announcements."""
+        self._origin_channel = channel
+        self._origin_chat_id = chat_id
+    
+    @property
+    def name(self) -> str:
+        return "spawn"
+    
+    @property
+    def description(self) -> str:
+        return (
+            "Spawn a subagent to handle a task in the background. "
+            "Use this for complex or time-consuming tasks that can run independently. "
+            "The subagent will complete the task and report back when done."
+        )
+    
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "task": {
+                    "type": "string",
+                    "description": "The task for the subagent to complete",
+                },
+                "label": {
+                    "type": "string",
+                    "description": "Optional short label for the task (for display)",
+                },
+            },
+            "required": ["task"],
+        }
+    
+    async def execute(self, task: str, label: str | None = None, **kwargs: Any) -> str:
+        """Spawn a subagent to execute the given task."""
+        return await self._manager.spawn(
+            task=task,
+            label=label,
+            origin_channel=self._origin_channel,
+            origin_chat_id=self._origin_chat_id,
+        )