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

honeymcp/api/app.py

@@ -15,7 +15,7 @@ from pydantic import BaseModel, Field
 
 from honeymcp.models.config import HoneyMCPConfig
 from honeymcp.models.events import AttackFingerprint
-from honeymcp.storage.event_store import get_event, list_events
+from honeymcp.storage.event_store import clear_events, get_event, list_events
 
 
 class EventListResponse(BaseModel):
@@ -48,6 +48,13 @@ class FiltersResponse(BaseModel):
     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],
@@ -177,6 +184,14 @@ def create_app(config_path: Optional[Path | str] = None) -> FastAPI:
             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),

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/core/fingerprinter.py

@@ -38,6 +38,7 @@ async def fingerprint_attack(
     arguments: Dict[str, Any],
     context: Any,
     ghost_spec: GhostToolSpec,
+    response_sent: Optional[str] = None,
 ) -> AttackFingerprint:
     """Capture complete attack context when a ghost tool is triggered.
 
@@ -61,8 +62,8 @@ async def fingerprint_attack(
     # Extract client metadata
     client_metadata = _extract_client_metadata(context)
 
-    # Generate fake response
-    fake_response = ghost_spec.response_generator(arguments)
+    # Use the exact response that was returned by middleware when provided.
+    fake_response = response_sent or ghost_spec.response_generator(arguments)
 
     # Create unique event ID
     event_id = f"evt_{datetime.utcnow().strftime('%Y%m%d_%H%M%S')}_{uuid4().hex[:8]}"

honeymcp/core/middleware.py

@@ -287,8 +287,8 @@ def honeypot(  # pylint: disable=too-many-arguments,too-many-positional-argument
                 else dynamic_ghost_specs.get(name)
             )
 
-            # Use standard fake response
-            fake_response = ghost_spec.response_generator(arguments or {})
+            # Use one response value for both MCP return and stored event.
+            fake_response = ghost_spec.response_generator(resolved_arguments or {})
 
             # Capture attack fingerprint
             fingerprint = await fingerprint_attack(
@@ -296,6 +296,7 @@ def honeypot(  # pylint: disable=too-many-arguments,too-many-positional-argument
                 arguments=resolved_arguments or {},
                 context=context,
                 ghost_spec=ghost_spec,
+                response_sent=fake_response,
             )
 
             # ATTACK DETECTED! Mark session as attacker and log details

honeymcp/dashboard/react_umd/app.js

@@ -159,7 +159,7 @@ function EventRow({ event }) {
   );
 }
 
-function FilterBar({ filters, options, onChange, onRefresh, loading, apiBase, onApiBaseChange }) {
+function FilterBar({ filters, options, onChange, onRefresh, onClear, loading, clearing, apiBase, onApiBaseChange }) {
   return (
     <section className="panel glass-panel">
       <div className="grid filters">
@@ -186,6 +186,12 @@ function FilterBar({ filters, options, onChange, onRefresh, loading, apiBase, on
             {loading ? "Refreshing..." : "Apply Filters"}
           </button>
         </div>
+
+        <div className="form-group">
+          <button className="danger" onClick={onClear} disabled={clearing || loading}>
+            {clearing ? "Clearing..." : "Clear Stored Data"}
+          </button>
+        </div>
       </div>
     </section>
   );
@@ -222,13 +228,15 @@ function App() {
   });
 
   const [loading, setLoading] = useState(false);
+  const [clearing, setClearing] = useState(false);
   const [error, setError] = useState(null);
+  const [notice, setNotice] = useState(null);
 
   // Data Fetching
-  const fetchJson = useCallback(async (path, queryParams = {}) => {
+  const fetchJson = useCallback(async (path, queryParams = {}, requestOptions = {}) => {
     const url = `${apiBase}${path}${buildQuery(queryParams)}`;
     try {
-      const response = await fetch(url);
+      const response = await fetch(url, requestOptions);
       if (!response.ok) throw new Error(`HTTP ${response.status}`);
       return await response.json();
     } catch (err) {
@@ -239,6 +247,7 @@ function App() {
   const loadData = useCallback(async () => {
     setLoading(true);
     setError(null);
+    setNotice(null);
     try {
       // Parallel fetch
       const [filterData, metricsData, eventsResp] = await Promise.all([
@@ -281,6 +290,28 @@ function App() {
     setFilters(prev => ({ ...prev, [name]: value }));
   };
 
+  const handleClearData = async () => {
+    const shouldDelete = window.confirm("Delete all stored HoneyMCP events?");
+    if (!shouldDelete) {
+      return;
+    }
+
+    setClearing(true);
+    setError(null);
+    setNotice(null);
+
+    try {
+      const result = await fetchJson("/events", {}, { method: "DELETE" });
+      setNotice(`Deleted ${result.deleted_events || 0} event(s).`);
+      await loadData();
+    } catch (err) {
+      console.error(err);
+      setError("Unable to clear stored events.");
+    } finally {
+      setClearing(false);
+    }
+  };
+
   return (
     <div className="container">
       <header className="header">
@@ -300,11 +331,19 @@ function App() {
         options={options}
         onChange={handleFilterChange}
         onRefresh={loadData}
+        onClear={handleClearData}
         loading={loading}
+        clearing={clearing}
         apiBase={apiBase}
         onApiBaseChange={setApiBase}
       />
 
+      {notice && (
+        <div className="panel panel-notice">
+          <span>{notice}</span>
+        </div>
+      )}
+
       {error && (
         <div className="panel" style={{ borderColor: 'var(--critical-border)', background: 'var(--critical-bg)', color: 'var(--critical-text)' }}>
           <div style={{ display: 'flex', gap: '12px', alignItems: 'center' }}>

honeymcp/dashboard/react_umd/styles.css

@@ -236,9 +236,26 @@
    box-shadow: 0 6px 8px rgba(217, 119, 6, 0.4);
  }
 
- button.primary:active {
-   transform: translateY(0);
- }
+button.primary:active {
+  transform: translateY(0);
+}
+
+button.danger {
+  background: linear-gradient(135deg, #b91c1c 0%, #991b1b 100%);
+  color: white;
+  border: none;
+  font-weight: 600;
+  cursor: pointer;
+}
+
+button.danger:hover {
+  background: linear-gradient(135deg, #dc2626 0%, #b91c1c 100%);
+}
+
+button:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
 
  /* Metrics */
  .metric-card {
@@ -429,11 +446,17 @@
  }
 
  /* Fallback/Empty States */
- .empty-state {
-   text-align: center;
-   padding: 64px 0;
-   color: var(--text-secondary);
- }
+.empty-state {
+  text-align: center;
+  padding: 64px 0;
+  color: var(--text-secondary);
+}
+
+.panel-notice {
+  border-color: rgba(134, 239, 172, 0.5);
+  background: rgba(22, 101, 52, 0.18);
+  color: #bbf7d0;
+}
 
  /* Loading Skeleton */
  .skeleton {
@@ -509,4 +532,4 @@
 
  ::-webkit-scrollbar-thumb:hover {
    background-color: var(--slate-600);
- }
+ }

honeymcp/storage/event_store.py

@@ -174,3 +174,38 @@ async def update_event(
                 continue
 
     return False
+
+
+async def clear_events(storage_path: Optional[Path] = None) -> int:
+    """Delete all persisted attack events.
+
+    Args:
+        storage_path: Base directory for event storage
+
+    Returns:
+        Number of event JSON files deleted
+    """
+    storage_path = resolve_event_storage_path(storage_path)
+    if not storage_path.exists():
+        return 0
+
+    deleted_count = 0
+
+    for date_dir in storage_path.iterdir():
+        if not date_dir.is_dir():
+            continue
+
+        for json_file in date_dir.glob("*.json"):
+            try:
+                json_file.unlink()
+                deleted_count += 1
+            except Exception as e:
+                print(f"Warning: Failed to delete {json_file}: {e}")
+
+        try:
+            date_dir.rmdir()
+        except OSError:
+            # Keep directory when it still has non-event files/subdirs.
+            continue
+
+    return deleted_count

{honeymcp-0.1.3.dist-info → honeymcp-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: honeymcp
-Version: 0.1.3
+Version: 0.1.4
 Summary: Deception middleware for AI agents - detecting data theft and indirect prompt injection in MCP servers
 Project-URL: Homepage, https://github.com/barvhaim/HoneyMCP
 Project-URL: Documentation, https://github.com/barvhaim/HoneyMCP#readme
@@ -133,6 +133,8 @@ MCP_TRANSPORT=sse uv run python examples/demo_server_dynamic.py
 make run-ui
 ```
 
+<img width="1426" height="972" alt="image" src="https://github.com/user-attachments/assets/2dfc37a2-8caa-4338-b7f7-1cbac7ed9d79" />
+
 ---
 
 ## 🎭 How It Works
@@ -275,8 +277,18 @@ mcp = honeypot(mcp, protection_mode=ProtectionMode.COGNITIVE)
 The easiest way to configure HoneyMCP:
 ```bash
 honeymcp init  # Creates honeymcp.yaml + .env.honeymcp
+# Optional: remove all persisted attack event files
+honeymcp clean-data
 ```
 
+### Clear Stored Events
+
+You can remove all persisted event JSON files from CLI, API, or UI:
+
+- CLI: `honeymcp clean-data`
+- API: `DELETE /events`
+- Dashboard: Use the **Clear Stored Data** button
+
 ### YAML Config
 
 ```yaml
@@ -551,244 +563,17 @@ The new tool is immediately available in your honeypot catalog.
 
 ---
 
-## ❓ FAQ
-
-### Can attackers detect the honeypots?
-
-While it's theoretically possible for a sophisticated attacker to identify honeypots through careful analysis, it's **highly improbable** in practice:
-
-- **Dynamic honeypots** are generated by LLM to match your server's domain and naming patterns, making them indistinguishable from legitimate tools
-- **Tool descriptions** are crafted to appear as restricted/privileged versions of real functionality
-- **No behavioral differences** - honeypots respond with realistic data, not errors or suspicious patterns
-- **MCP protocol limitation** - AI agents cannot inspect tool implementation, only names and descriptions
-
-Detection would require:
-1. Prior knowledge of your specific tool catalog
-2. Ability to distinguish between legitimate privileged tools and honeypots
-3. Understanding that deception is being employed
-
-For most attack scenarios (automated scanners, opportunistic attacks, indirect prompt injection), detection is effectively impossible.
-
-### Will this slow down my MCP server?
-
-No. HoneyMCP adds negligible overhead:
-- **~1ms per tool call** for interception logic
-- **Async event logging** doesn't block tool execution
-- **Zero impact on legitimate tools** - they execute normally
-- **LLM calls only at startup** for dynamic honeypot generation (cached for subsequent requests)
-
-### What if I don't have LLM credentials?
-
-HoneyMCP works perfectly without LLM access:
-- Set `use_dynamic_tools=False` to use **static mode**
-- Pre-configured generic honeypots work out-of-the-box
-- No external dependencies or API calls required
-- Slightly less convincing than dynamic honeypots, but still effective
-
-### How do I know if I'm being attacked?
-
-Multiple indicators:
-- **Dashboard alerts** - Real-time visualization of attack events
-- **Event logs** - JSON files in `~/.honeymcp/events/` with complete attack context
-- **Webhook notifications** (optional) - Configure Slack/Discord alerts
-- **Tool call sequences** - See exactly what the attacker tried before triggering honeypot
-
-### Does this work with all MCP clients?
-
-HoneyMCP is designed for **FastMCP servers** and works with any MCP-compatible client:
-- ✅ Claude Desktop (stdio and HTTP transports)
-- ✅ Custom MCP clients
-- ✅ Any client following MCP protocol specification
-
-The detection mechanism is client-agnostic - it operates at the server level.
-
-### What's the difference between SCANNER and COGNITIVE modes?
-
-**SCANNER mode (default):**
-- Immediate lockout after honeypot trigger
-- All subsequent tools return errors
-- Best for automated attacks and quick containment
-
-**COGNITIVE mode:**
-- Sustained deception after honeypot trigger
-- Real tools return synthetic/mock data
-- Keeps attacker engaged for intelligence gathering
-- Best for sophisticated attacks and red team exercises
+## Documentation
 
+- [FAQ](docs/faq.md)
+- [Architecture](docs/architecture.md)
+- [Use Cases](docs/use-cases.md)
+- [Security Considerations](docs/security-considerations.md)
+- [Development](docs/development.md)
+- [CLI Reference](docs/cli-reference.md)
 ---
-
-## 🏗️ Architecture
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                        AI Agent (Claude)                     │
-└────────────────────┬───────────────────────▲────────────────┘
-                     │                        │
-                     │ MCP Protocol           │
-                     ▼                        │
-┌─────────────────────────────────────────────────────────────┐
-│                    HoneyMCP Middleware                       │
-│  ┌────────────────────────────────────────────────────────┐ │
-│  │ Tool Call Interceptor                                  │ │
-│  │  ├─ Is ghost tool?                                    │ │
-│  │  │   YES: Fingerprint + Store + Return fake data      │ │
-│  │  │   NO:  Pass through to legitimate tool             │ │
-│  └────────────────────────────────────────────────────────┘ │
-│                                                              │
-│  Ghost Tools: [list_cloud_secrets, execute_shell_command]   │
-│  Real Tools:  [safe_calculator, get_weather, ...]           │
-└─────────────────────────────────────────────────────────────┘
-                     │                        ▲
-                     ▼                        │
-         ┌──────────────────┐    ┌──────────────────┐
-         │ Event Storage    │    │ Your Real Tools  │
-         │ ~/.honeymcp/     │    │                  │
-         └──────────────────┘    └──────────────────┘
-                     │
-                     ▼
-         ┌──────────────────┐
-         │ React            │
-         │ Dashboard        │
-         └──────────────────┘
-```
-
 ---
 
-## 🎓 Use Cases
-
-### 1. Production Monitoring
-Deploy HoneyMCP in production to detect attacks targeting your AI agents:
-- **Customer support bots** - Detect attempts to exfiltrate customer data or inject malicious responses
-- **Internal AI assistants** - Catch data theft attempts targeting internal credentials or documents
-- **Code generation tools** - Detect injection of malicious code or unauthorized file access
-- **Data analysis agents** - Identify attempts to steal sensitive datasets or manipulate outputs
-
-### 2. Red Team Testing
-Use HoneyMCP to validate your AI security defenses:
-- Test if your AI filters catch data exfiltration attempts
-- Measure indirect prompt injection success rates
-- Gather TTPs for threat modeling
-
-### 3. Security Research
-Study AI agent attack techniques in the wild:
-- Capture real-world exfiltration patterns
-- Analyze indirect prompt injection payloads
-- Build threat intelligence database
-
-### 4. Compliance & Auditing
-Demonstrate security controls for AI systems:
-- Prove attack detection capabilities for data theft and injection attacks
-- Generate audit logs of attempted attacks
-- Meet AI security compliance requirements
-
-## Security Considerations
-
-### Detection Capabilities
-✅ Detects data exfiltration attempts via GET-style honeypots  
-✅ Detects indirect prompt injection via SET-style honeypots  
-✅ Captures complete attack context and telemetry  
-✅ Returns synthetic data to maintain deception
-
-### Limitations
-❌ Detection-only system (does not prevent attacks)  
-❌ Does not sanitize or filter user input  
-❌ Not a replacement for input validation and security controls  
-❌ Cannot guarantee conversation history capture (MCP protocol limitation)
-
-**Deploy HoneyMCP as part of defense-in-depth strategy, not as a standalone security control.**
-
-
-### Best Practices
-1. **Defense in Depth** - Use HoneyMCP alongside input filters, not as a replacement
-2. **Monitor the Dashboard** - Regularly review attack patterns for both exfiltration and injection
-3. **Investigate Alerts** - Each ghost tool call is a high-confidence attack signal
-4. **Secure Storage** - Protect `~/.honeymcp/events/` (contains attack data)
-
----
-
-## 💻 CLI Reference
-
-HoneyMCP includes a command-line tool for setup and management.
-
-### Initialize Configuration
-
-```bash
-honeymcp init [--directory DIR] [--force]
-```
-
-Creates `honeymcp.yaml` and `.env.honeymcp` in the target directory.
-
-Options:
-- `-d, --directory` - Target directory (default: current directory)
-- `-f, --force` - Overwrite existing files
-
-### Show Version
-
-```bash
-honeymcp version
-```
-
----
-
-## 🛠️ Development
-
-### Install from Source
-
-```bash
-git clone https://github.com/barvhaim/HoneyMCP.git
-cd HoneyMCP
-uv sync
-
-# Run tests
-uv run pytest
-
-# Lint & format
-make lint
-make format
-```
-
-### Project Structure
-
-```
-HoneyMCP/
-├── src/honeymcp/
-│   ├── __init__.py              # Main exports
-│   ├── cli.py                   # CLI (honeymcp init, version)
-│   ├── core/
-│   │   ├── middleware.py        # @honeypot decorator
-│   │   ├── ghost_tools.py       # Ghost tool catalog
-│   │   ├── fingerprinter.py     # Attack context capture
-│   │   └── dynamic_ghost_tools.py# LLM-driven ghost tool generation
-│   ├── models/
-│   │   ├── events.py            # AttackFingerprint model
-│   │   ├── ghost_tool_spec.py   # GhostToolSpec definition
-│   │   └── config.py            # Configuration
-│   ├── llm/
-│   │   ├── analyzers.py          # Tool extraction and categorization
-│   │   ├── clients/              # LLM providers (Watsonx/OpenAI/RITS)
-│   │   └── prompts/              # Prompt templates
-│   ├── integrations/            # External integrations
-│   ├── storage/
-│   │   └── event_store.py       # JSON event persistence
-│   └── dashboard/
-│       └── react_umd/           # React dashboard assets
-├── examples/
-│   ├── demo_server.py           # Static ghost tools demo
-│   └── demo_server_dynamic.py   # Dynamic ghost tools demo
-├── tests/                       # Pytest suite (e2e + dynamic tools)
-├── pyproject.toml               # Dependencies
-└── README.md                    # This file
-```
-
-### Tests
-
-```bash
-uv run pytest
-```
-
-Notes:
-- Dynamic tool tests require LLM credentials in `.env.honeymcp` and will skip if env vars are missing.
-
 ## 📄 License
 
 Apache 2.0 - See [LICENSE](LICENSE) for details.

{honeymcp-0.1.3.dist-info → honeymcp-0.1.4.dist-info}/RECORD

@@ -1,19 +1,19 @@
 honeymcp/__init__.py,sha256=iDVDF3MHCnR3zMdUQbeyutrJTuzzjlK-nEmdm-UqH90,881
-honeymcp/cli.py,sha256=EexwRLQhdC8bwFsOijhCF_ovtcI1vjE_QhqZIn5-CN8,6021
+honeymcp/cli.py,sha256=JoXD3dDS8oJJ5ll70p7ufQf4JZbTWZAFC6Y8slabULA,7592
 honeymcp/cli_tool_creator.py,sha256=5rGRMcA5KbbfFz6O6ou4OgBPrBLTNna-skUhsjKp-KI,3784
 honeymcp/api/__init__.py,sha256=L_4Y-NOh4jBQgHxgX35h8XzsmpmleS3WHHJkU-tF35Y,40
-honeymcp/api/app.py,sha256=R39yuxCAR1tTR7YX7euS1rRF6CG2sSl0VFUweuEGzZE,7618
+honeymcp/api/app.py,sha256=Wqu9l3c6iFPLXBpoxp0e51wKcr3MnPTkAV15Bgk6Z0Y,8131
 honeymcp/core/__init__.py,sha256=ja7k0fPJebDbfmGlhkpaMJa76NNaLCIpnGS7rUUdPn8,525
 honeymcp/core/catalog_updater.py,sha256=qZsKKrADjd5wWMjXGphPXHE-NNncaAT45fig81bupGY,10971
 honeymcp/core/dynamic_ghost_tools.py,sha256=GHaWZN7_XSCcXj204T4TMZyeI682WOT_JycMiM3gfp4,16731
-honeymcp/core/fingerprinter.py,sha256=I_GrcWiQJthzH6z5Yjwtyq18Y4NxM5zeBI0Oft5Lkrc,9768
+honeymcp/core/fingerprinter.py,sha256=ZZ5gSyvWrop3R0XAR1-gU62iwyA5Dl8Dup_QKbYR2AE,9873
 honeymcp/core/ghost_tools.py,sha256=VFFAt7mjH1XhJANCRfjhgDV1bp14zxGXKt9-nzaH7x4,34890
-honeymcp/core/middleware.py,sha256=rMSSFI2FPDZXggcMg7UQQvGQbosR-WjWnl9P4AXXXbI,25816
+honeymcp/core/middleware.py,sha256=KWL3xmXHBt8KIEKio2iF4_Eozkqwr25uvdtle-kbWDo,25904
 honeymcp/core/tool_creator.py,sha256=6Vn8c7EzTBTuqgsPLr2qPDJ6C4Al9lwb6ahdy1oFZTQ,18693
 honeymcp/dashboard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-honeymcp/dashboard/react_umd/app.js,sha256=zThv9cAyIiXONFK6JI51YLLBZLGBQQxwakQSldeux2c,12045
+honeymcp/dashboard/react_umd/app.js,sha256=9Qee_EllLzSgWsGwRvH_oq_K250raKzR12RD2WWBbnE,13180
 honeymcp/dashboard/react_umd/index.html,sha256=2bOkKUzcGpx0TUmN0W-57VBW8apOJS9NaCbWAT2ezHM,1147
-honeymcp/dashboard/react_umd/styles.css,sha256=xyLr5kuYfBTs8gbMeZkZxJh4x7IiGIyu6gwut7sMqoo,10829
+honeymcp/dashboard/react_umd/styles.css,sha256=koZBNTOm5exwLkzi4NWRIfPIYlBc333zjVluyMJnXWw,11245
 honeymcp/integrations/__init__.py,sha256=C-f4H12hXKa2a-taQDR1iBa6nF_S5Xt-bKpgownLI6U,67
 honeymcp/llm/__init__.py,sha256=55pJKDg15XFn7nUpOtdo5GhEDdmup5YBG-g4Lfc-5vE,256
 honeymcp/llm/analyzers.py,sha256=f_92wHNfIqLlU2KlNfPzFyrVFOwUfxU8efyrmD2x1Vg,9104
@@ -27,9 +27,9 @@ honeymcp/models/events.py,sha256=OHUjChjjjbM5GK-zEQ-o2njDY-zJeGLvLdjWhIJz-OE,227
 honeymcp/models/ghost_tool_spec.py,sha256=KM_M-e4Ys_jr3rUfREDiZ-oa331KWcyt5B7zMD7MeZU,917
 honeymcp/models/protection_mode.py,sha256=mo1_EnBeIOzyHxgEpReZx4lMJ6m__36edUWDJMzuRak,523
 honeymcp/storage/__init__.py,sha256=seOZHWpojp1fU65OFuLcNqJaBihrlNyUPeq9BDwAEVI,207
-honeymcp/storage/event_store.py,sha256=mneqVxkTi0bVbTOdxhIYBCjia0Wv59A6FudNRdgvphE,5431
-honeymcp-0.1.3.dist-info/METADATA,sha256=_nj55_KPvnDG4jYct7aiPZ9ieKLw-7DdRPgzW8jRUJ0,28671
-honeymcp-0.1.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-honeymcp-0.1.3.dist-info/entry_points.txt,sha256=KYXb49Xp3SEP3cNmUDwuAXJNFwsLHwPxEIj6UEhOj2k,47
-honeymcp-0.1.3.dist-info/licenses/LICENSE,sha256=TRR6-30aYl9D43FJPmJ8diBUP_RwDg61LNW2rt87HE8,636
-honeymcp-0.1.3.dist-info/RECORD,,
+honeymcp/storage/event_store.py,sha256=RYcgI-HCoX6CGNnEB_WwShLBxyg1q9KhvH2qmSIXhwo,6337
+honeymcp-0.1.4.dist-info/METADATA,sha256=SOdoUS1iI3fpBKlmgB5VVG1r0dmzMf__FuesL6aDVh0,19295
+honeymcp-0.1.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+honeymcp-0.1.4.dist-info/entry_points.txt,sha256=KYXb49Xp3SEP3cNmUDwuAXJNFwsLHwPxEIj6UEhOj2k,47
+honeymcp-0.1.4.dist-info/licenses/LICENSE,sha256=TRR6-30aYl9D43FJPmJ8diBUP_RwDg61LNW2rt87HE8,636
+honeymcp-0.1.4.dist-info/RECORD,,