Remove old middleware and consolidate to unified event-driven tracking

This commit completes the middleware consolidation by removing deprecated
components and switching to a unified event-driven architecture:

**Removed old middleware classes:**
- MCPMMonitoringMiddleware -> replaced by MCPMUnifiedTrackingMiddleware
- MCPMUsageTrackingMiddleware -> replaced by MCPMUnifiedTrackingMiddleware

**Removed deprecated database code:**
- usage_sessions table and all related queries
- track_session method from AccessMonitor interface
- session_tracker.py module and its exports

**Updated tracking approach:**
- All tracking now uses events (SESSION_START/SESSION_END) with session_id linking
- Usage statistics computed at query time from events table
- Simplified method delegation to computed stats
- Maintained backward compatibility for metadata formats

**Benefits:**
- Single unified middleware handles all tracking automatically
- Event-driven architecture enables rich analytics
- Simplified codebase with consistent patterns
- Better session correlation via session_id

All tests pass and usage command works correctly with computed statistics.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: niechen

CLAUDE.md

@@ -0,0 +1,7 @@
+# Claude Project Conventions
+
+This file contains conventions that Claude should follow when working on this project.
+
+- **Formatting:** Always format Python code with `ruff`.
+- **Dependency Management:** Use `uv` for all Python dependency management.
+- **Committing:** Always double-check with the user before committing changes to git.

src/mcpm/commands/profile/run.py

@@ -8,6 +8,7 @@
 from rich.panel import Panel
 
 from mcpm.fastmcp_integration.proxy import create_mcpm_proxy
+# Removed SessionAction import - using strings directly
 from mcpm.profile.profile_config import ProfileConfigManager
 from mcpm.utils.config import DEFAULT_PORT
 from mcpm.utils.logging_config import (
@@ -52,6 +53,8 @@ async def run_profile_fastmcp(profile_servers, profile_name, http_mode=False, po
             servers=profile_servers,
             name=f"profile-{profile_name}",
             stdio_mode=not http_mode,  # stdio_mode=False for HTTP
+            action="profile_run",
+            profile_name=profile_name,
         )
 
         logger.debug(f"FastMCP proxy initialized with: {[s.name for s in profile_servers]}")
@@ -62,10 +65,7 @@ async def run_profile_fastmcp(profile_servers, profile_name, http_mode=False, po
         # Re-suppress library logging after FastMCP initialization
         ensure_dependency_logging_suppressed()
 
-        # Record profile usage
-        from mcpm.commands.usage import record_profile_usage
-
-        record_profile_usage(profile_name, "run" + ("_http" if http_mode else ""))
+        # Note: Usage tracking is handled by proxy middleware
 
         if http_mode:
             # Try to find an available port if the requested one is taken

src/mcpm/commands/run.py

@@ -2,8 +2,6 @@
 
 import asyncio
 import logging
-import os
-import subprocess
 import sys
 
 import click
@@ -12,6 +10,7 @@
 
 from mcpm.fastmcp_integration.proxy import create_mcpm_proxy
 from mcpm.global_config import GlobalConfigManager
+# Removed SessionAction import - using strings directly
 from mcpm.utils.config import DEFAULT_PORT
 from mcpm.utils.logging_config import (
     ensure_dependency_logging_suppressed,
@@ -32,76 +31,22 @@ def find_installed_server(server_name):
     return None, None
 
 
-def execute_server_command(server_config, server_name):
-    """Execute a server command with proper environment setup."""
-    if not server_config:
-        logger.error(f"Invalid server configuration for '{server_name}'")
-        sys.exit(1)
-
-    # Get command and args from the server config
-    command = server_config.command
-    args = server_config.args or []
-
-    if not command:
-        logger.error(f"Invalid command format for server '{server_name}'")
-        sys.exit(1)
-
-    # Build the full command list
-    full_command = [command] + args
-
-    # Set up environment
-    env = os.environ.copy()
-
-    # Add any environment variables from server config
-    if hasattr(server_config, "env") and server_config.env:
-        for key, value in server_config.env.items():
-            env[key] = str(value)
-
-    # Set working directory if specified
-    cwd = getattr(server_config, "cwd", None)
-    if cwd:
-        cwd = os.path.expanduser(cwd)
-
-    try:
-        # Record usage
-        from mcpm.commands.usage import record_server_usage
-
-        record_server_usage(server_name, "run")
-
-        # Execute the command
-        result = subprocess.run(full_command, env=env, cwd=cwd, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr)
-
-        return result.returncode
-
-    except FileNotFoundError:
-        logger.error(f"Command not found: {full_command[0]}")
-        logger.warning("Make sure the required runtime is installed")
-        sys.exit(1)
-    except KeyboardInterrupt:
-        logger.info("Server execution interrupted")
-        logger.warning("\nServer execution interrupted")
-        sys.exit(130)
-    except Exception as e:
-        logger.error(f"Error running server '{server_name}': {e}")
-        sys.exit(1)
-
 
 async def run_server_with_fastmcp(server_config, server_name, http_mode=False, port=None):
     """Run server using FastMCP proxy (stdio or HTTP)."""
     try:
         # Use default port if none specified
         if port is None:
             port = DEFAULT_PORT
-        # Record usage
-        from mcpm.commands.usage import record_server_usage
-
-        record_server_usage(server_name, "run" + ("_http" if http_mode else ""))
+        # Note: Usage tracking is handled by proxy middleware
 
         # Create FastMCP proxy for single server
+        action = "run_http" if http_mode else "run"
         proxy = await create_mcpm_proxy(
             servers=[server_config],
             name=f"mcpm-run-{server_name}",
             stdio_mode=not http_mode,  # stdio_mode=False for HTTP
+            action=action,
         )
 
         # Set up dependency logging for FastMCP/MCP libraries
@@ -216,7 +161,7 @@ def run(server_name, http, port):
         # Use FastMCP proxy for HTTP mode
         exit_code = asyncio.run(run_server_with_fastmcp(server_config, server_name, http_mode=True, port=port))
     else:
-        # Use direct execution for stdio mode (maintains backwards compatibility)
-        exit_code = execute_server_command(server_config, server_name)
+        # Use FastMCP proxy for stdio mode (enables middleware and usage tracking)
+        exit_code = asyncio.run(run_server_with_fastmcp(server_config, server_name, http_mode=False, port=port))
 
     sys.exit(exit_code)

src/mcpm/commands/share.py

@@ -15,6 +15,7 @@
 from mcpm.core.tunnel import Tunnel
 from mcpm.fastmcp_integration.proxy import create_mcpm_proxy
 from mcpm.global_config import GlobalConfigManager
+# Removed SessionAction import - using strings directly
 from mcpm.utils.config import DEFAULT_PORT, DEFAULT_SHARE_ADDRESS
 from mcpm.utils.logging_config import (
     ensure_dependency_logging_suppressed,
@@ -81,10 +82,7 @@ async def start_fastmcp_proxy(
     logger.debug(f"Starting FastMCP proxy for server '{server_name}' on port {actual_port}")
 
     try:
-        # Record usage
-        from mcpm.commands.usage import record_server_usage
-
-        record_server_usage(server_name, "share")
+        # Note: Usage tracking is handled by proxy middleware
 
         # Create FastMCP proxy for single server (HTTP mode for sharing)
         proxy = await create_mcpm_proxy(
@@ -93,6 +91,7 @@ async def start_fastmcp_proxy(
             stdio_mode=False,  # HTTP mode for sharing
             auth_enabled=auth_enabled,
             api_key=api_key,
+            action="share",
         )
 
         logger.debug(f"FastMCP proxy ready on port {actual_port}")