honeymcp 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

honeymcp/api/__init__.py

@@ -0,0 +1 @@
+"""FastAPI application for HoneyMCP."""

honeymcp/api/app.py

@@ -0,0 +1,233 @@
+"""HoneyMCP FastAPI service for dashboard consumption."""
+
+from __future__ import annotations
+
+import os
+from datetime import date, datetime, timedelta
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+
+from honeymcp.models.config import HoneyMCPConfig
+from honeymcp.models.events import AttackFingerprint
+from honeymcp.storage.event_store import clear_events, get_event, list_events
+
+
+class EventListResponse(BaseModel):
+    """Paginated event list response."""
+
+    total: int = Field(description="Total events matching the filters")
+    count: int = Field(description="Number of events returned in this page")
+    offset: int = Field(description="Offset for pagination")
+    limit: int = Field(description="Limit for pagination")
+    events: List[AttackFingerprint] = Field(description="Event records")
+
+
+class MetricsResponse(BaseModel):
+    """Aggregate metrics for dashboard summaries."""
+
+    total_attacks: int
+    attacks_last_24h: int
+    critical_threats: int
+    unique_tools: int
+    unique_sessions: int
+    by_threat_level: Dict[str, int]
+    by_category: Dict[str, int]
+
+
+class FiltersResponse(BaseModel):
+    """Distinct filter values for UI dropdowns."""
+
+    threat_levels: List[str]
+    categories: List[str]
+    tools: List[str]
+
+
+class ClearEventsResponse(BaseModel):
+    """Response returned when stored events are deleted."""
+
+    deleted_events: int
+    storage_path: str
+
+
+def _apply_filters(
+    events: List[AttackFingerprint],
+    threat_level: Optional[str],
+    category: Optional[str],
+    tool: Optional[str],
+) -> List[AttackFingerprint]:
+    filtered = events
+    if threat_level:
+        filtered = [
+            event
+            for event in filtered
+            if event.threat_level.lower() == threat_level.lower()
+        ]
+    if category:
+        filtered = [event for event in filtered if event.attack_category == category]
+    if tool:
+        filtered = [event for event in filtered if event.ghost_tool_called == tool]
+    return filtered
+
+
+def _metrics(events: List[AttackFingerprint]) -> MetricsResponse:
+    now = datetime.utcnow()
+    total_attacks = len(events)
+    attacks_last_24h = len([event for event in events if now - event.timestamp < timedelta(days=1)])
+    critical_threats = len([event for event in events if event.threat_level == "critical"])
+    unique_tools = len({event.ghost_tool_called for event in events})
+    unique_sessions = len({event.session_id for event in events})
+
+    by_threat_level: Dict[str, int] = {}
+    by_category: Dict[str, int] = {}
+    for event in events:
+        by_threat_level[event.threat_level] = by_threat_level.get(event.threat_level, 0) + 1
+        by_category[event.attack_category] = by_category.get(event.attack_category, 0) + 1
+
+    return MetricsResponse(
+        total_attacks=total_attacks,
+        attacks_last_24h=attacks_last_24h,
+        critical_threats=critical_threats,
+        unique_tools=unique_tools,
+        unique_sessions=unique_sessions,
+        by_threat_level=by_threat_level,
+        by_category=by_category,
+    )
+
+
+def _configure_cors(app: FastAPI) -> None:
+    origins_raw = os.getenv("HONEYMCP_API_CORS_ORIGINS", "").strip()
+    if not origins_raw:
+        return
+    origins = [origin.strip() for origin in origins_raw.split(",") if origin.strip()]
+    if not origins:
+        return
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+
+def create_app(config_path: Optional[Path | str] = None) -> FastAPI:
+    """Create a FastAPI app configured with HoneyMCP settings."""
+    config = HoneyMCPConfig.load(config_path)
+
+    app = FastAPI(
+        title="HoneyMCP API",
+        version="0.1.0",
+        description="HTTP API for HoneyMCP dashboard consumption",
+    )
+    _configure_cors(app)
+
+    app.state.config = config
+    app.state.event_storage_path = config.event_storage_path
+    dashboard_root = Path(__file__).resolve().parent.parent / "dashboard" / "react_umd"
+    app.state.dashboard_root = dashboard_root
+
+    if dashboard_root.exists():
+        app.mount(
+            "/dashboard/assets",
+            StaticFiles(directory=str(dashboard_root)),
+            name="dashboard_assets",
+        )
+
+    @app.get("/health")
+    async def health() -> Dict[str, str]:
+        return {"status": "ok", "timestamp": datetime.utcnow().isoformat() + "Z"}
+
+    @app.get("/dashboard")
+    @app.get("/dashboard/", include_in_schema=False)
+    async def react_dashboard() -> FileResponse:
+        index_path = app.state.dashboard_root / "index.html"
+        if not index_path.exists():
+            raise HTTPException(status_code=404, detail="Dashboard UI not found")
+        return FileResponse(index_path)
+
+    @app.get("/events", response_model=EventListResponse)
+    async def get_events(
+        start_date: Optional[date] = Query(default=None),
+        end_date: Optional[date] = Query(default=None),
+        threat_level: Optional[str] = Query(default=None),
+        category: Optional[str] = Query(default=None),
+        tool: Optional[str] = Query(default=None),
+        limit: int = Query(default=200, ge=1, le=1000),
+        offset: int = Query(default=0, ge=0),
+    ) -> EventListResponse:
+        events = await list_events(
+            storage_path=app.state.event_storage_path,
+            start_date=start_date,
+            end_date=end_date,
+        )
+        filtered = _apply_filters(events, threat_level, category, tool)
+        total = len(filtered)
+        page = filtered[offset : offset + limit]
+        return EventListResponse(
+            total=total,
+            count=len(page),
+            offset=offset,
+            limit=limit,
+            events=page,
+        )
+
+    @app.get("/events/{event_id}", response_model=AttackFingerprint)
+    async def get_event_by_id(event_id: str) -> AttackFingerprint:
+        event = await get_event(event_id, storage_path=app.state.event_storage_path)
+        if event is None:
+            raise HTTPException(status_code=404, detail="Event not found")
+        return event
+
+    @app.delete("/events", response_model=ClearEventsResponse)
+    async def delete_events() -> ClearEventsResponse:
+        deleted_count = await clear_events(storage_path=app.state.event_storage_path)
+        return ClearEventsResponse(
+            deleted_events=deleted_count,
+            storage_path=str(app.state.event_storage_path),
+        )
+
+    @app.get("/metrics", response_model=MetricsResponse)
+    async def get_metrics(
+        start_date: Optional[date] = Query(default=None),
+        end_date: Optional[date] = Query(default=None),
+        threat_level: Optional[str] = Query(default=None),
+        category: Optional[str] = Query(default=None),
+        tool: Optional[str] = Query(default=None),
+    ) -> MetricsResponse:
+        events = await list_events(
+            storage_path=app.state.event_storage_path,
+            start_date=start_date,
+            end_date=end_date,
+        )
+        filtered = _apply_filters(events, threat_level, category, tool)
+        return _metrics(filtered)
+
+    @app.get("/filters", response_model=FiltersResponse)
+    async def get_filters(
+        start_date: Optional[date] = Query(default=None),
+        end_date: Optional[date] = Query(default=None),
+    ) -> FiltersResponse:
+        events = await list_events(
+            storage_path=app.state.event_storage_path,
+            start_date=start_date,
+            end_date=end_date,
+        )
+        threat_levels = sorted({event.threat_level for event in events})
+        categories = sorted({event.attack_category for event in events})
+        tools = sorted({event.ghost_tool_called for event in events})
+        return FiltersResponse(
+            threat_levels=threat_levels,
+            categories=categories,
+            tools=tools,
+        )
+
+    return app
+
+
+app = create_app()

honeymcp/cli.py

@@ -1,9 +1,13 @@
 """HoneyMCP CLI - Command line tools for HoneyMCP setup and management."""
 
+import asyncio
 import argparse
 import sys
 from pathlib import Path
 
+from honeymcp.models.config import HoneyMCPConfig
+from honeymcp.storage.event_store import clear_events
+
 CONFIG_TEMPLATE = """\
 # HoneyMCP Configuration
 # ======================
@@ -156,6 +160,27 @@ def cmd_version(args: argparse.Namespace) -> int:
     return 0
 
 
+def cmd_clean_data(args: argparse.Namespace) -> int:
+    """Delete stored HoneyMCP attack events."""
+    storage_path: Path
+    if args.path:
+        storage_path = Path(args.path).expanduser()
+    else:
+        config = HoneyMCPConfig.load(args.config)
+        storage_path = config.event_storage_path
+
+    if not args.yes:
+        print(f"This will permanently delete all stored events in: {storage_path}")
+        confirm = input("Continue? [y/N]: ").strip().lower()
+        if confirm not in {"y", "yes"}:
+            print("Aborted.")
+            return 0
+
+    deleted_count = asyncio.run(clear_events(storage_path=storage_path))
+    print(f"Deleted {deleted_count} event file(s) from {storage_path}")
+    return 0
+
+
 def main() -> int:
     """Main CLI entry point."""
     parser = argparse.ArgumentParser(
@@ -191,6 +216,29 @@ def main() -> int:
     )
     version_parser.set_defaults(func=cmd_version)
 
+    clean_data_parser = subparsers.add_parser(
+        "clean-data",
+        help="Delete all stored attack event data",
+        description="Remove persisted event JSON files from HoneyMCP storage",
+    )
+    clean_data_parser.add_argument(
+        "--path",
+        default=None,
+        help="Event storage directory (overrides config and env resolution)",
+    )
+    clean_data_parser.add_argument(
+        "--config",
+        default=None,
+        help="Path to honeymcp.yaml (optional, default lookup order applies)",
+    )
+    clean_data_parser.add_argument(
+        "-y",
+        "--yes",
+        action="store_true",
+        help="Skip confirmation prompt",
+    )
+    clean_data_parser.set_defaults(func=cmd_clean_data)
+
     # Parse and execute
     args = parser.parse_args()
 

honeymcp/cli_tool_creator.py

@@ -0,0 +1,110 @@
+"""CLI command for creating new honeypot tools."""
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+from honeymcp.core.tool_creator import ToolCreatorAgent
+from honeymcp.core.catalog_updater import CatalogUpdater
+
+
+def create_tool_command(description: str, project_root: Optional[Path] = None) -> int:
+    """CLI command to create a new honeypot tool.
+    
+    Args:
+        description: Natural language description of the tool
+        project_root: Optional project root path
+        
+    Returns:
+        Exit code (0 for success, 1 for failure)
+    """
+    print("🍯 HoneyMCP Tool Creator")
+    print("=" * 50)
+    print(f"\nDescription: {description}\n")
+    
+    # Step 1: Create tool using ReAct agent
+    print("Step 1: Analyzing description and generating tool specification...")
+    agent = ToolCreatorAgent()
+    success, tool_spec, errors = agent.create_tool(description)
+    
+    if not success:
+        print("❌ Failed to create tool specification:")
+        for error in errors:
+            print(f"  - {error}")
+        return 1
+    
+    print(f"✅ Tool specification created: {tool_spec.name}")
+    print(f"   Category: {tool_spec.attack_category}")
+    print(f"   Threat Level: {tool_spec.threat_level}")
+    
+    # Show reasoning process
+    state = agent.get_state_summary()
+    if state["reasoning"]:
+        print("\n📝 Agent Reasoning:")
+        for i, thought in enumerate(state["reasoning"], 1):
+            print(f"   {i}. {thought}")
+    
+    if state["reflections"]:
+        print("\n🔍 Quality Reflections:")
+        for i, reflection in enumerate(state["reflections"], 1):
+            print(f"   {i}. {reflection}")
+    
+    # Step 2: Get response function code
+    print("\nStep 2: Extracting response generator code...")
+    # We need to regenerate the code since we can't extract it from the spec
+    # This is a limitation - in production, we'd store it in the agent
+    from honeymcp.core.tool_creator import ToolSpecification
+    
+    # Recreate spec for code generation
+    temp_spec = ToolSpecification(
+        name=tool_spec.name,
+        description=tool_spec.description,
+        parameters=tool_spec.parameters,
+        required_params=tool_spec.parameters.get("required", []),
+        category=agent._determine_category(description),
+        threat_level=agent._determine_threat_level(description),
+        response_template=""
+    )
+    response_func_code = agent._generate_response_function(temp_spec)
+    print(f"✅ Response generator created ({len(response_func_code)} chars)")
+    
+    # Step 3: Update catalog
+    print("\nStep 3: Adding tool to catalog...")
+    updater = CatalogUpdater(project_root)
+    success, errors = updater.add_tool_complete(tool_spec, response_func_code)
+    
+    if not success:
+        print("❌ Failed to update catalog:")
+        for error in errors:
+            print(f"  - {error}")
+        return 1
+    
+    print("✅ Tool added to ghost_tools.py")
+    print("✅ Handler added to middleware.py")
+    
+    # Step 4: Summary
+    print("\n" + "=" * 50)
+    print("✅ Tool creation complete!")
+    print(f"\nNew tool: {tool_spec.name}")
+    print(f"Description: {tool_spec.description}")
+    print(f"\nTo use this tool:")
+    print(f'  mcp = honeypot(mcp, ghost_tools=["{tool_spec.name}"])')
+    print("\nOr it will be available in dynamic mode automatically.")
+    
+    return 0
+
+
+def main():
+    """Main CLI entry point."""
+    if len(sys.argv) < 2:
+        print("Usage: honeymcp create-tool <description>")
+        print("\nExample:")
+        print('  honeymcp create-tool "dump container registry credentials"')
+        return 1
+    
+    description = " ".join(sys.argv[1:])
+    return create_tool_command(description)
+
+
+if __name__ == "__main__":
+    sys.exit(main())