devduck 0.4.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

devduck/tools/agentcore_logs.py

@@ -0,0 +1,320 @@
+"""AgentCore Logs Tool - View CloudWatch logs from deployed DevDuck instances."""
+
+from datetime import datetime, timedelta
+from typing import Any, Dict, Optional
+from strands import tool
+
+
+@tool
+def agentcore_logs(
+    action: str = "recent",
+    agent_name: str = "devduck",
+    limit: int = 50,
+    start_time: Optional[str] = None,
+    end_time: Optional[str] = None,
+    filter_pattern: Optional[str] = None,
+    log_stream_name: Optional[str] = None,
+    endpoint: str = "DEFAULT",
+    region: str = "us-west-2",
+) -> Dict[str, Any]:
+    """View CloudWatch logs from deployed DevDuck instances on AgentCore.
+
+    Args:
+        action: Log operation (recent, streams, search, tail)
+        agent_name: Name of deployed agent (default: devduck)
+        limit: Max events/streams to return (default: 50)
+        start_time: Start time in ISO format (default: last hour)
+        end_time: End time in ISO format (default: now)
+        filter_pattern: CloudWatch filter pattern for search
+        log_stream_name: Specific stream to tail
+        endpoint: Endpoint qualifier (default: DEFAULT)
+        region: AWS region (default: us-west-2)
+
+    Returns:
+        Dict with status and log content
+
+    Examples:
+        # Recent logs
+        agentcore_logs(agent_name="devduck")
+
+        # Search for errors
+        agentcore_logs(
+            action="search",
+            filter_pattern="ERROR"
+        )
+
+        # List streams
+        agentcore_logs(action="streams")
+
+        # Tail specific stream
+        agentcore_logs(
+            action="tail",
+            log_stream_name="2025/11/16/[runtime-logs]session-abc"
+        )
+    """
+    try:
+        import boto3
+        import yaml
+        from pathlib import Path
+        from botocore.exceptions import ClientError
+
+        # Load config to get agent ID
+        devduck_dir = Path(__file__).parent.parent
+        config_path = devduck_dir / ".bedrock_agentcore.yaml"
+
+        if not config_path.exists():
+            return {
+                "status": "error",
+                "content": [
+                    {"text": "Agent not configured. Run agentcore_launch() first."}
+                ],
+            }
+
+        with open(config_path) as f:
+            config = yaml.safe_load(f)
+
+        # Get agent ID
+        if "agents" not in config or agent_name not in config["agents"]:
+            return {
+                "status": "error",
+                "content": [{"text": f"Agent '{agent_name}' not found in config"}],
+            }
+
+        agent_id = (
+            config["agents"][agent_name].get("bedrock_agentcore", {}).get("agent_id")
+        )
+
+        if not agent_id:
+            return {
+                "status": "error",
+                "content": [
+                    {
+                        "text": f"Agent '{agent_name}' not deployed. Run agentcore_launch()."
+                    }
+                ],
+            }
+
+        # CloudWatch client
+        logs_client = boto3.client("logs", region_name=region)
+
+        # Build log group name
+        log_group_name = f"/aws/bedrock-agentcore/runtimes/{agent_id}-{endpoint}"
+
+        # Route to appropriate handler
+        if action == "recent":
+            return _get_recent_logs(
+                logs_client, log_group_name, limit, start_time, end_time, filter_pattern
+            )
+        elif action == "streams":
+            return _list_log_streams(logs_client, log_group_name, limit)
+        elif action == "search":
+            if not filter_pattern:
+                return {
+                    "status": "error",
+                    "content": [{"text": "filter_pattern required for search"}],
+                }
+            return _search_logs(
+                logs_client, log_group_name, filter_pattern, limit, start_time, end_time
+            )
+        elif action == "tail":
+            if not log_stream_name:
+                log_stream_name = _get_latest_stream(logs_client, log_group_name)
+                if not log_stream_name:
+                    return {
+                        "status": "error",
+                        "content": [{"text": "No log streams found"}],
+                    }
+            return _tail_logs(logs_client, log_group_name, log_stream_name, limit)
+        else:
+            return {
+                "status": "error",
+                "content": [{"text": f"Unknown action: {action}"}],
+            }
+
+    except ClientError as e:
+        error_code = e.response["Error"]["Code"]
+        if error_code == "ResourceNotFoundException":
+            return {
+                "status": "error",
+                "content": [
+                    {"text": f"Log group not found: {log_group_name}"},
+                    {"text": "Agent may not be deployed or hasn't logged yet"},
+                ],
+            }
+        return {"status": "error", "content": [{"text": f"AWS Error: {str(e)}"}]}
+    except Exception as e:
+        return {"status": "error", "content": [{"text": f"Error: {str(e)}"}]}
+
+
+def _get_recent_logs(
+    client,
+    log_group_name: str,
+    limit: int,
+    start_time: Optional[str],
+    end_time: Optional[str],
+    filter_pattern: Optional[str],
+) -> Dict[str, Any]:
+    """Get recent log events."""
+    params = {
+        "logGroupName": log_group_name,
+        "limit": limit,
+        "interleaved": True,
+    }
+
+    if start_time:
+        start_dt = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
+        params["startTime"] = int(start_dt.timestamp() * 1000)
+    else:
+        # Default: last 5 minutes for truly recent logs
+        params["startTime"] = int(
+            (datetime.now() - timedelta(minutes=5)).timestamp() * 1000
+        )
+
+    if end_time:
+        end_dt = datetime.fromisoformat(end_time.replace("Z", "+00:00"))
+        params["endTime"] = int(end_dt.timestamp() * 1000)
+
+    if filter_pattern:
+        params["filterPattern"] = filter_pattern
+
+    response = client.filter_log_events(**params)
+    events = response.get("events", [])
+
+    if not events:
+        return {
+            "status": "success",
+            "content": [{"text": "No log events found in last 5 minutes"}],
+        }
+
+    # Sort by timestamp descending (most recent first)
+    events.sort(key=lambda e: e["timestamp"], reverse=True)
+
+    # Format logs
+    log_lines = []
+    for event in events:
+        timestamp = datetime.fromtimestamp(event["timestamp"] / 1000).strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+        message = event["message"].rstrip()
+        log_lines.append(f"[{timestamp}] {message}")
+
+    return {
+        "status": "success",
+        "content": [
+            {"text": f"Found {len(events)} log events:\n"},
+            {"text": "\n".join(log_lines)},
+        ],
+    }
+
+
+def _list_log_streams(client, log_group_name: str, limit: int) -> Dict[str, Any]:
+    """List log streams."""
+    response = client.describe_log_streams(
+        logGroupName=log_group_name,
+        orderBy="LastEventTime",
+        descending=True,
+        limit=limit,
+    )
+
+    streams = response.get("logStreams", [])
+
+    if not streams:
+        return {"status": "success", "content": [{"text": "No log streams found"}]}
+
+    stream_lines = [f"Found {len(streams)} log streams:\n"]
+    for stream in streams:
+        stream_name = stream["logStreamName"]
+        last_event = datetime.fromtimestamp(
+            stream.get("lastEventTimestamp", 0) / 1000
+        ).strftime("%Y-%m-%d %H:%M:%S")
+        stream_lines.append(f"• {stream_name} (last: {last_event})")
+
+    return {"status": "success", "content": [{"text": "\n".join(stream_lines)}]}
+
+
+def _search_logs(
+    client,
+    log_group_name: str,
+    filter_pattern: str,
+    limit: int,
+    start_time: Optional[str],
+    end_time: Optional[str],
+) -> Dict[str, Any]:
+    """Search logs with pattern."""
+    params = {
+        "logGroupName": log_group_name,
+        "filterPattern": filter_pattern,
+        "limit": limit,
+        "interleaved": True,
+    }
+
+    if start_time:
+        start_dt = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
+        params["startTime"] = int(start_dt.timestamp() * 1000)
+    else:
+        params["startTime"] = int(
+            (datetime.now() - timedelta(hours=24)).timestamp() * 1000
+        )
+
+    if end_time:
+        end_dt = datetime.fromisoformat(end_time.replace("Z", "+00:00"))
+        params["endTime"] = int(end_dt.timestamp() * 1000)
+
+    response = client.filter_log_events(**params)
+    events = response.get("events", [])
+
+    if not events:
+        return {
+            "status": "success",
+            "content": [{"text": f"No matches for pattern: {filter_pattern}"}],
+        }
+
+    log_lines = [f"Found {len(events)} matches:\n"]
+    for event in events:
+        timestamp = datetime.fromtimestamp(event["timestamp"] / 1000).strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+        message = event["message"].rstrip()
+        log_lines.append(f"[{timestamp}] {message}")
+
+    return {"status": "success", "content": [{"text": "\n".join(log_lines)}]}
+
+
+def _tail_logs(
+    client, log_group_name: str, log_stream_name: str, limit: int
+) -> Dict[str, Any]:
+    """Tail specific log stream."""
+    response = client.get_log_events(
+        logGroupName=log_group_name,
+        logStreamName=log_stream_name,
+        limit=limit,
+        startFromHead=False,
+    )
+
+    events = response.get("events", [])
+
+    if not events:
+        return {
+            "status": "success",
+            "content": [{"text": f"No events in stream: {log_stream_name}"}],
+        }
+
+    log_lines = [f"Latest {len(events)} events:\n"]
+    for event in events:
+        timestamp = datetime.fromtimestamp(event["timestamp"] / 1000).strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+        message = event["message"].rstrip()
+        log_lines.append(f"[{timestamp}] {message}")
+
+    return {"status": "success", "content": [{"text": "\n".join(log_lines)}]}
+
+
+def _get_latest_stream(client, log_group_name: str) -> Optional[str]:
+    """Get latest log stream."""
+    response = client.describe_log_streams(
+        logGroupName=log_group_name, orderBy="LastEventTime", descending=True, limit=1
+    )
+
+    streams = response.get("logStreams", [])
+    return streams[0]["logStreamName"] if streams else None

devduck/tools/ambient.py

@@ -0,0 +1,157 @@
+"""
+Ambient input overlay control tool - integrated with devduck
+"""
+
+from strands import tool
+from typing import Dict, Any
+import subprocess
+import socket
+import json
+import tempfile
+import os
+import time
+import signal
+import sys
+from pathlib import Path
+
+# Global state
+_ambient_process = None
+
+
+def _send_command(command: Dict) -> Dict:
+    """Send command to ambient input overlay"""
+    socket_path = os.path.join(tempfile.gettempdir(), "devduck_ambient.sock")
+
+    try:
+        client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        client.settimeout(2.0)
+        client.connect(socket_path)
+        client.sendall(json.dumps(command).encode("utf-8"))
+
+        response_data = client.recv(4096)
+        client.close()
+
+        if not response_data:
+            return {"status": "error", "message": "Empty response"}
+
+        return json.loads(response_data.decode("utf-8"))
+    except socket.timeout:
+        return {"status": "error", "message": "Timeout"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+
+@tool
+def ambient(
+    action: str,
+    text: str = None,
+) -> Dict[str, Any]:
+    """Control ambient AI input overlay.
+
+    Args:
+        action: Action to perform
+            - "start": Start ambient overlay
+            - "stop": Stop overlay
+            - "show": Show overlay
+            - "hide": Hide overlay
+            - "status": Check if running
+            - "set_text": Pre-fill text
+        text: Text to pre-fill (for set_text action)
+
+    Returns:
+        Dict with status and content
+
+    Features:
+        🎨 Modern glassmorphism UI
+        ⚡ Blinking cursor with auto-focus
+        🌊 Real-time IPC streaming from devduck
+        📦 Structured message handling
+        ⌨️ ESC to hide, Enter to send
+    """
+    global _ambient_process
+
+    if action == "start":
+        if _ambient_process and _ambient_process.poll() is None:
+            return {"status": "success", "content": [{"text": "✓ Already running"}]}
+
+        # Get ambient script path (in same directory as this file)
+        tools_dir = Path(__file__).parent
+        ambient_script = tools_dir / "_ambient_input.py"
+
+        if not ambient_script.exists():
+            return {
+                "status": "error",
+                "content": [{"text": f"❌ Ambient script not found: {ambient_script}"}],
+            }
+
+        _ambient_process = subprocess.Popen(
+            [sys.executable, str(ambient_script)],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+        time.sleep(1.5)
+
+        return {
+            "status": "success",
+            "content": [
+                {"text": f"✓ Ambient overlay started (PID: {_ambient_process.pid})"}
+            ],
+        }
+
+    elif action == "stop":
+        if _ambient_process:
+            try:
+                os.kill(_ambient_process.pid, signal.SIGTERM)
+                _ambient_process.wait(timeout=3)
+            except:
+                pass
+            _ambient_process = None
+
+        return {"status": "success", "content": [{"text": "✓ Stopped"}]}
+
+    elif action == "status":
+        is_running = _ambient_process and _ambient_process.poll() is None
+        return {"status": "success", "content": [{"text": f"Running: {is_running}"}]}
+
+    elif action == "show":
+        result = _send_command({"action": "show"})
+        if result.get("status") == "success":
+            return {"status": "success", "content": [{"text": "✓ Overlay shown"}]}
+        else:
+            return {
+                "status": "error",
+                "content": [
+                    {"text": f"Failed: {result.get('message', 'Unknown error')}"}
+                ],
+            }
+
+    elif action == "hide":
+        result = _send_command({"action": "hide"})
+        if result.get("status") == "success":
+            return {"status": "success", "content": [{"text": "✓ Overlay hidden"}]}
+        else:
+            return {
+                "status": "error",
+                "content": [
+                    {"text": f"Failed: {result.get('message', 'Unknown error')}"}
+                ],
+            }
+
+    elif action == "set_text":
+        if not text:
+            return {"status": "error", "content": [{"text": "text parameter required"}]}
+
+        result = _send_command({"action": "set_text", "text": text})
+        if result.get("status") == "success":
+            return {"status": "success", "content": [{"text": f"✓ Text set: {text}"}]}
+        else:
+            return {
+                "status": "error",
+                "content": [
+                    {"text": f"Failed: {result.get('message', 'Unknown error')}"}
+                ],
+            }
+
+    else:
+        return {"status": "error", "content": [{"text": f"Unknown action: {action}"}]}