open-edison 0.1.10__py3-none-any.whl → 0.1.15__py3-none-any.whl

src/middleware/session_tracking.py

@@ -29,6 +29,11 @@ from sqlalchemy.sql import select
 
 from src.config import get_config_dir  # type: ignore[reportMissingImports]
 from src.middleware.data_access_tracker import DataAccessTracker
+from src.telemetry import (
+    record_prompt_used,
+    record_resource_used,
+    record_tool_call,
+)
 
 
 @dataclass
@@ -165,6 +170,13 @@ def get_session_from_db(session_id: str) -> MCPSession:
                 data_access_tracker.has_external_communication = trifecta.get(
                     "has_external_communication", False
                 )
+            # Restore ACL highest level if present
+            if isinstance(summary_data, dict) and "acl" in summary_data:
+                acl_summary: Any = summary_data.get("acl")  # type: ignore
+                if isinstance(acl_summary, dict):
+                    highest = acl_summary.get("highest_acl_level")  # type: ignore
+                    if isinstance(highest, str) and highest:
+                        data_access_tracker.highest_acl_level = highest
 
         return MCPSession(
             session_id=session_id,
@@ -285,6 +297,8 @@ class SessionTrackingMiddleware(Middleware):
         assert session.data_access_tracker is not None
         log.debug(f"🔍 Analyzing tool {context.message.name} for security implications")
         _ = session.data_access_tracker.add_tool_call(context.message.name)
+        # Telemetry: record tool call
+        record_tool_call(context.message.name)
 
         # Update database session
         with create_db_session() as db_session:
@@ -383,6 +397,7 @@ class SessionTrackingMiddleware(Middleware):
 
         log.debug(f"🔍 Analyzing resource {resource_name} for security implications")
         _ = session.data_access_tracker.add_resource_access(resource_name)
+        record_resource_used(resource_name)
 
         # Update database session
         with create_db_session() as db_session:
@@ -463,6 +478,7 @@ class SessionTrackingMiddleware(Middleware):
 
         log.debug(f"🔍 Analyzing prompt {prompt_name} for security implications")
         _ = session.data_access_tracker.add_prompt_access(prompt_name)
+        record_prompt_used(prompt_name)
 
         # Update database session
         with create_db_session() as db_session:

src/server.py

@@ -6,6 +6,7 @@ No multi-user support, no complex routing - just a straightforward proxy.
 """
 
 import asyncio
+import traceback
 from collections.abc import Awaitable, Callable, Coroutine
 from pathlib import Path
 from typing import Any, cast
@@ -16,7 +17,9 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, JSONResponse, Response
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
 from fastapi.staticfiles import StaticFiles
+from fastmcp import FastMCP
 from loguru import logger as log
+from pydantic import BaseModel, Field
 
 from src.config import MCPServerConfig, config
 from src.config import get_config_dir as _get_cfg_dir  # type: ignore[attr-defined]
@@ -26,6 +29,7 @@ from src.middleware.session_tracking import (
     create_db_session,
 )
 from src.single_user_mcp import SingleUserMCP
+from src.telemetry import initialize_telemetry, set_servers_installed
 
 
 def _get_current_config():
@@ -177,21 +181,33 @@ class OpenEdisonProxy:
         }
 
         def _resolve_json_path(filename: str) -> Path:
-            # JSON files reside in the config directory
+            """
+            Resolve a JSON config file path consistently with src.config defaults.
+
+            Precedence for reads (and writes if chosen):
+            1) Repository root next to src/ (editable/dev) if file exists
+            2) Config dir (OPEN_EDISON_CONFIG_DIR or platform default)
+               - If missing, bootstrap from repo root default when available
+            3) Current working directory as last resort
+            """
+            # 1) Prefer repository root next to src/
+            repo_candidate = Path(__file__).parent.parent / filename
+            if repo_candidate.exists():
+                return repo_candidate
+
+            # 2) Config directory
             try:
                 base = _get_cfg_dir()
             except Exception:
                 base = Path.cwd()
             target = base / filename
-            # If missing and we ship a default in package root, bootstrap it
-            if not target.exists():
+            if (not target.exists()) and repo_candidate.exists():
                 try:
-                    pkg_default = Path(__file__).parent.parent / filename
-                    if pkg_default.exists():
-                        target.write_text(pkg_default.read_text(encoding="utf-8"), encoding="utf-8")
+                    target.parent.mkdir(parents=True, exist_ok=True)
+                    target.write_text(repo_candidate.read_text(encoding="utf-8"), encoding="utf-8")
                 except Exception:
                     pass
-            return target
+            return target if target.exists() else repo_candidate
 
         async def _serve_json(filename: str) -> Response:  # type: ignore[override]
             if filename not in allowed_json_files:
@@ -261,12 +277,26 @@ class OpenEdisonProxy:
 
         return app
 
+    def _build_backend_config_top(
+        self, server_name: str, body: "OpenEdisonProxy._ValidateRequest"
+    ) -> dict[str, Any]:
+        backend_entry: dict[str, Any] = {
+            "command": body.command,
+            "args": body.args,
+            "env": body.env or {},
+        }
+        if body.roots:
+            backend_entry["roots"] = body.roots
+        return {"mcpServers": {server_name: backend_entry}}
+
     async def start(self) -> None:
         """Start the Open Edison proxy server"""
         log.info("🚀 Starting Open Edison MCP Proxy Server")
         log.info(f"FastAPI management API on {self.host}:{self.port + 1}")
         log.info(f"FastMCP protocol server on {self.host}:{self.port}")
 
+        initialize_telemetry()
+
         # Ensure the sessions database exists and has the required schema
         try:
             with create_db_session():
@@ -277,6 +307,10 @@ class OpenEdisonProxy:
         # Initialize the FastMCP server (this handles starting enabled MCP servers)
         await self.single_user_mcp.initialize()
 
+        # Emit snapshot of enabled servers
+        enabled_count = len([s for s in config.mcp_servers if s.enabled])
+        set_servers_installed(enabled_count)
+
         # Add CORS middleware to FastAPI
         self.fastapi_app.add_middleware(
             CORSMiddleware,
@@ -336,6 +370,12 @@ class OpenEdisonProxy:
             methods=["POST"],
             dependencies=[Depends(self.verify_api_key)],
         )
+        app.add_api_route(
+            "/mcp/validate",
+            self.validate_mcp_server,
+            methods=["POST"],
+            # Intentionally no auth required for validation for now
+        )
         app.add_api_route(
             "/mcp/{server_name}/stop",
             self.stop_mcp_server,
@@ -558,3 +598,151 @@ class OpenEdisonProxy:
         except Exception as e:
             log.error(f"Failed to fetch sessions: {e}")
             raise HTTPException(status_code=500, detail="Failed to fetch sessions") from e
+
+    # ---- MCP validation ----
+    class _ValidateRequest(BaseModel):
+        name: str | None = Field(None, description="Optional server name label")
+        command: str = Field(..., description="Executable to run, e.g. 'npx' or 'uvx'")
+        args: list[str] = Field(default_factory=list, description="Arguments to the command")
+        env: dict[str, str] | None = Field(
+            default=None,
+            description="Environment variables for the subprocess (values should already exist)",
+        )
+        roots: list[str] | None = Field(
+            default=None, description="Optional allowed roots for the MCP server"
+        )
+        timeout_s: float | None = Field(20.0, description="Overall timeout for validation")
+
+    async def validate_mcp_server(self, body: _ValidateRequest) -> dict[str, Any]:  # noqa: C901
+        """
+        Validate an MCP server by launching it via FastMCP and listing capabilities.
+
+        Returns tools, resources, and prompts if successful.
+        """
+
+        server_name = body.name or "validation"
+        backend_cfg = self._build_backend_config_top(server_name, body)
+
+        log.info(
+            f"Validating MCP server command for '{server_name}': {body.command} {' '.join(body.args)}"
+        )
+
+        server: FastMCP[Any] | None = None
+        try:
+            # Guard for template entries with no command configured
+            if not body.command or not body.command.strip():
+                return {
+                    "valid": False,
+                    "error": "No command configured (template entry)",
+                    "server": {
+                        "name": server_name,
+                        "command": body.command,
+                        "args": body.args,
+                        "has_roots": bool(body.roots),
+                    },
+                }
+
+            server = FastMCP.as_proxy(
+                backend=backend_cfg, name=f"open-edison-validate-{server_name}"
+            )
+            tools, resources, prompts = await self._list_all_capabilities(server, body)
+
+            return {
+                "valid": True,
+                "server": {
+                    "name": server_name,
+                    "command": body.command,
+                    "args": body.args,
+                    "has_roots": bool(body.roots),
+                },
+                "tools": [self._safe_tool(t) for t in tools],
+                "resources": [self._safe_resource(r) for r in resources],
+                "prompts": [self._safe_prompt(p) for p in prompts],
+            }
+        except TimeoutError as te:  # noqa: PERF203
+            log.error(f"MCP validation timed out: {te}\n{traceback.format_exc()}")
+            return {
+                "valid": False,
+                "error": "Validation timed out",
+                "server": {
+                    "name": server_name,
+                    "command": body.command,
+                    "args": body.args,
+                    "has_roots": bool(body.roots),
+                },
+            }
+        except Exception as e:  # noqa: BLE001
+            log.error(f"MCP validation failed: {e}\n{traceback.format_exc()}")
+            return {
+                "valid": False,
+                "error": str(e),
+                "server": {
+                    "name": server_name,
+                    "command": body.command,
+                    "args": body.args,
+                    "has_roots": bool(body.roots),
+                },
+            }
+        finally:
+            # Best-effort cleanup if FastMCP exposes a shutdown/close
+            try:
+                if isinstance(server, FastMCP):
+                    result = server.shutdown()  # type: ignore[attr-defined]
+                    # If it returns an awaitable, await it
+                    if isinstance(result, Awaitable):
+                        await result  # type: ignore[func-returns-value]
+            except Exception as cleanup_err:  # noqa: BLE001
+                log.debug(f"Validator cleanup skipped/failed: {cleanup_err}")
+
+    def _build_backend_config(
+        self, server_name: str, body: "OpenEdisonProxy._ValidateRequest"
+    ) -> dict[str, Any]:
+        backend_entry: dict[str, Any] = {
+            "command": body.command,
+            "args": body.args,
+            "env": body.env or {},
+        }
+        if body.roots:
+            backend_entry["roots"] = body.roots
+        return {"mcpServers": {server_name: backend_entry}}
+
+    async def _list_all_capabilities(
+        self, server: FastMCP[Any], body: "OpenEdisonProxy._ValidateRequest"
+    ) -> tuple[list[Any], list[Any], list[Any]]:
+        s: Any = server
+
+        async def _call_list(kind: str) -> list[Any]:
+            # Prefer public list_*; fallback to _list_* for proxies that expose private methods
+            for attr in (f"list_{kind}", f"_list_{kind}"):
+                if hasattr(s, attr):
+                    method = getattr(s, attr)
+                    return await method()
+            raise AttributeError(f"Proxy does not expose list method for {kind}")
+
+        async def list_all() -> tuple[list[Any], list[Any], list[Any]]:
+            tools = await _call_list("tools")
+            resources = await _call_list("resources")
+            prompts = await _call_list("prompts")
+            return tools, resources, prompts
+
+        timeout = body.timeout_s if isinstance(body.timeout_s, (int | float)) else 20.0
+        return await asyncio.wait_for(list_all(), timeout=timeout)
+
+    def _safe_tool(self, t: Any) -> dict[str, Any]:
+        name = getattr(t, "name", None)
+        description = getattr(t, "description", None)
+        return {"name": str(name) if name is not None else "", "description": description}
+
+    def _safe_resource(self, r: Any) -> dict[str, Any]:
+        uri = getattr(r, "uri", None)
+        try:
+            uri_str = str(uri) if uri is not None else ""
+        except Exception:
+            uri_str = ""
+        description = getattr(r, "description", None)
+        return {"uri": uri_str, "description": description}
+
+    def _safe_prompt(self, p: Any) -> dict[str, Any]:
+        name = getattr(p, "name", None)
+        description = getattr(p, "description", None)
+        return {"name": str(name) if name is not None else "", "description": description}

src/telemetry.py

@@ -0,0 +1,336 @@
+"""
+Telemetry for Open Edison (opt-out).
+This module provides a thin, optional wrapper around OpenTelemetry to export
+basic usage metrics to an OTLP endpoint. If telemetry is disabled or the
+OpenTelemetry packages are not installed, all functions are safe no-ops.
+
+Events/metrics captured (high level, install-unique ID for deaggregation):
+- tool_calls_total (counter)
+- tool_calls_blocked_total (counter)
+- servers_installed_total (up-down counter / gauge)
+- tool_calls_metadata_total (counter)
+- resource_used_total (counter)
+- prompt_used_total (counter)
+- private_data_access_calls_total (counter)
+- untrusted_public_data_calls_total (counter)
+- write_operation_calls_total (counter)
+
+Configuration: see `TelemetryConfig` in `src.config`.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import traceback
+import uuid
+from collections.abc import Callable
+from typing import Any, ParamSpec, TypeVar
+
+from loguru import logger as log
+
+# OpenTelemetry metrics components
+from opentelemetry import metrics as ot_metrics
+from opentelemetry.exporter.otlp.proto.http import metric_exporter as otlp_metric_exporter
+from opentelemetry.sdk import metrics as ot_sdk_metrics
+from opentelemetry.sdk.metrics import export as ot_metrics_export
+from opentelemetry.sdk.resources import Resource  # type: ignore[reportMissingTypeStubs]
+
+from src.config import TelemetryConfig, config, get_config_dir
+
+_initialized: bool = False
+_install_id: str | None = None
+_provider: Any | None = None
+_tool_calls_counter: Any | None = None
+_tool_calls_blocked_counter: Any | None = None
+_servers_installed_gauge: Any | None = None
+_tool_calls_metadata_counter: Any | None = None
+_resource_used_counter: Any | None = None
+_prompt_used_counter: Any | None = None
+_private_data_access_counter: Any | None = None
+_untrusted_public_data_counter: Any | None = None
+_write_operation_counter: Any | None = None
+_resource_access_blocked_counter: Any | None = None
+_prompt_access_blocked_counter: Any | None = None
+
+
+def _ensure_install_id() -> str:
+    """Create or read a persistent install-unique ID under the config dir."""
+    global _install_id
+    if _install_id:
+        return _install_id
+    try:
+        cfg_dir = get_config_dir()
+        cfg_dir.mkdir(parents=True, exist_ok=True)
+    except Exception:  # noqa: BLE001
+        log.error(
+            "Could not resolve or create config dir for install_id; using ephemeral ID\n{}",
+            traceback.format_exc(),
+        )
+        _install_id = str(uuid.uuid4())
+        return _install_id
+
+    id_file = cfg_dir / "install_id"
+    if id_file.exists():
+        try:
+            _install_id = id_file.read_text(encoding="utf-8").strip() or str(uuid.uuid4())
+        except Exception:  # noqa: BLE001
+            log.error(
+                "Failed reading install_id file; using ephemeral ID\n{}",
+                traceback.format_exc(),
+            )
+            _install_id = str(uuid.uuid4())
+    else:
+        _install_id = str(uuid.uuid4())
+        try:
+            id_file.write_text(_install_id, encoding="utf-8")
+        except Exception:  # noqa: BLE001
+            log.error(
+                "Failed writing install_id file; continuing without persistence\n{}",
+                traceback.format_exc(),
+            )
+    return _install_id
+
+
+def _telemetry_enabled() -> bool:
+    tel_cfg = config.telemetry or TelemetryConfig()
+    return bool(tel_cfg.enabled)
+
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def telemetry_recorder(func: Callable[P, R]) -> Callable[P, R | None]:  # noqa: UP047
+    """No-op when disabled, ensure init, and catch/log failures."""
+
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R | None:  # type: ignore[override]
+        if not _telemetry_enabled():
+            return None
+        if not _initialized:
+            initialize_telemetry()
+        try:
+            return func(*args, **kwargs)
+        except Exception:  # noqa: BLE001
+            log.error("Telemetry emit failed\n{}", traceback.format_exc())
+            return None
+
+    return wrapper
+
+
+def initialize_telemetry(override: TelemetryConfig | None = None) -> None:  # noqa: C901
+    """Initialize telemetry if enabled in config.
+
+    Safe to call multiple times; only first call initializes.
+    """
+    global \
+        _initialized, \
+        _provider, \
+        _tool_calls_counter, \
+        _tool_calls_blocked_counter, \
+        _servers_installed_gauge
+
+    if _initialized:
+        return
+
+    telemetry_cfg = override if override is not None else (config.telemetry or TelemetryConfig())
+    if not telemetry_cfg.enabled:
+        log.debug("Telemetry disabled by config")
+        _initialized = True
+        return
+
+    # Exporter
+    exporter_kwargs: dict[str, Any] = {}
+    if telemetry_cfg.otlp_endpoint:
+        exporter_kwargs["endpoint"] = telemetry_cfg.otlp_endpoint
+    # Allow environment variables to provide endpoint when not set in config
+    env_endpoint = os.environ.get("OTEL_EXPORTER_OTLP_METRICS_ENDPOINT") or os.environ.get(
+        "OTEL_EXPORTER_OTLP_ENDPOINT"
+    )
+    if "endpoint" not in exporter_kwargs and env_endpoint:
+        exporter_kwargs["endpoint"] = env_endpoint
+    # If no endpoint is available from config or env, skip initialization quietly
+    if "endpoint" not in exporter_kwargs:
+        log.debug("No OTLP endpoint configured (config or env); skipping telemetry init")
+        _initialized = True
+        return
+    if telemetry_cfg.headers:
+        exporter_kwargs["headers"] = telemetry_cfg.headers
+
+    try:
+        exporter: Any = otlp_metric_exporter.OTLPMetricExporter(**exporter_kwargs)
+    except Exception:  # noqa: BLE001
+        log.error("OTLP exporter init failed\n{}", traceback.format_exc())
+        return
+
+    # Reader
+    try:
+        reader: Any = ot_metrics_export.PeriodicExportingMetricReader(
+            exporter=exporter,
+            export_interval_millis=max(1000, telemetry_cfg.export_interval_ms),
+        )
+    except Exception:  # noqa: BLE001
+        log.error("OTLP reader init failed\n{}", traceback.format_exc())
+        return
+
+    # Provider/meter
+    try:
+        # Attach a resource so metrics include service identifiers
+        resource = Resource.create(
+            {
+                "service.name": "open-edison",
+                "service.namespace": "open-edison",
+                "telemetry.sdk.language": "python",
+            }
+        )
+        provider: Any = ot_sdk_metrics.MeterProvider(metric_readers=[reader], resource=resource)
+        _provider = provider
+        ot_metrics.set_meter_provider(provider)
+        meter: Any = ot_metrics.get_meter("open-edison")
+    except Exception:  # noqa: BLE001
+        log.error("Metrics provider init failed\n{}", traceback.format_exc())
+        return
+
+    # Instruments
+    try:
+        # Do not suffix counters with _total; Prometheus exporter appends it
+        _tool_calls_counter = meter.create_counter("tool_calls")
+        _tool_calls_blocked_counter = meter.create_counter("tool_calls_blocked")
+        _servers_installed_gauge = meter.create_up_down_counter("servers_installed")
+        _tool_calls_metadata_counter = meter.create_counter("tool_calls_metadata")
+        _resource_used_counter = meter.create_counter("resource_used")
+        _resource_access_blocked_counter = meter.create_counter("resource_access_blocked")
+        _prompt_used_counter = meter.create_counter("prompt_used")
+        _prompt_access_blocked_counter = meter.create_counter("prompt_access_blocked")
+        _private_data_access_counter = meter.create_counter("private_data_access_calls")
+        _untrusted_public_data_counter = meter.create_counter("untrusted_public_data_calls")
+        _write_operation_counter = meter.create_counter("write_operation_calls")
+    except Exception:  # noqa: BLE001
+        log.error("Metrics instrument creation failed\n{}", traceback.format_exc())
+        return
+
+    _ = _ensure_install_id()
+    _initialized = True
+    log.info("📈 Telemetry initialized")
+
+
+def force_flush_metrics(timeout_ms: int = 5000) -> bool:
+    """Force-flush metrics synchronously if a provider is initialized.
+
+    Returns True on success, False otherwise.
+    """
+    try:
+        provider = _provider
+        if provider is None:
+            return False
+        # Some providers expose force_flush(timeout_millis=...), others as force_flush() -> bool
+        if hasattr(provider, "force_flush"):
+            try:
+                # Try with timeout argument first
+                result = provider.force_flush(timeout_millis=timeout_ms)  # type: ignore[misc]
+            except TypeError:
+                result = provider.force_flush()
+            return bool(result)
+        return False
+    except Exception:  # noqa: BLE001
+        log.error("Force flush failed\n{}", traceback.format_exc())
+        return False
+
+
+def _common_attrs(extra: dict[str, Any] | None = None) -> dict[str, Any]:
+    attrs: dict[str, Any] = {"install_id": _ensure_install_id(), "app": "open-edison"}
+    if extra:
+        attrs.update(extra)
+    return attrs
+
+
+@telemetry_recorder
+def record_tool_call(tool_name: str) -> None:
+    if _tool_calls_counter is None:
+        return
+    _tool_calls_counter.add(1, attributes=_common_attrs({"tool": tool_name}))
+
+
+@telemetry_recorder
+def record_tool_call_blocked(tool_name: str, reason: str) -> None:
+    if _tool_calls_blocked_counter is None:
+        return
+    _tool_calls_blocked_counter.add(
+        1, attributes=_common_attrs({"tool": tool_name, "reason": reason})
+    )
+
+
+@telemetry_recorder
+def record_tool_call_metadata(tool_name: str, metadata: dict[str, Any]) -> None:
+    if _tool_calls_metadata_counter is None:
+        return
+    metadata_str = json.dumps(metadata, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+    _tool_calls_metadata_counter.add(
+        1, attributes=_common_attrs({"tool": tool_name, "metadata_json": metadata_str})
+    )
+
+
+@telemetry_recorder
+def set_servers_installed(count: int) -> None:
+    if _servers_installed_gauge is None:
+        return
+    _servers_installed_gauge.add(count, attributes=_common_attrs({"state": "snapshot"}))
+
+
+@telemetry_recorder
+def record_resource_used(resource_name: str) -> None:
+    if _resource_used_counter is None:
+        return
+    _resource_used_counter.add(1, attributes=_common_attrs({"resource": resource_name}))
+
+
+@telemetry_recorder
+def record_resource_access_blocked(resource_name: str, reason: str) -> None:
+    if _resource_access_blocked_counter is None:
+        return
+    _resource_access_blocked_counter.add(
+        1, attributes=_common_attrs({"resource": resource_name, "reason": reason})
+    )
+
+
+@telemetry_recorder
+def record_prompt_used(prompt_name: str) -> None:
+    if _prompt_used_counter is None:
+        return
+    _prompt_used_counter.add(1, attributes=_common_attrs({"prompt": prompt_name}))
+
+
+@telemetry_recorder
+def record_prompt_access_blocked(prompt_name: str, reason: str) -> None:
+    if _prompt_access_blocked_counter is None:
+        return
+    _prompt_access_blocked_counter.add(
+        1, attributes=_common_attrs({"prompt": prompt_name, "reason": reason})
+    )
+
+
+@telemetry_recorder
+def record_private_data_access(source_type: str, name: str) -> None:
+    if _private_data_access_counter is None:
+        return
+    _private_data_access_counter.add(
+        1, attributes=_common_attrs({"source_type": source_type, "name": name})
+    )
+
+
+@telemetry_recorder
+def record_untrusted_public_data(source_type: str, name: str) -> None:
+    if _untrusted_public_data_counter is None:
+        return
+    _untrusted_public_data_counter.add(
+        1, attributes=_common_attrs({"source_type": source_type, "name": name})
+    )
+
+
+@telemetry_recorder
+def record_write_operation(source_type: str, name: str) -> None:
+    if _write_operation_counter is None:
+        return
+    _write_operation_counter.add(
+        1, attributes=_common_attrs({"source_type": source_type, "name": name})
+    )

open_edison-0.1.10.dist-info/RECORD

@@ -1,17 +0,0 @@
-src/__init__.py,sha256=QWeZdjAm2D2B0eWhd8m2-DPpWvIP26KcNJxwEoU1oEQ,254
-src/__main__.py,sha256=kQsaVyzRa_ESC57JpKDSQJAHExuXme0rM5beJsYxFeA,161
-src/cli.py,sha256=ketV-e9oQMVlLBjZR7YbK33XkEfqxPyzWqYkS1YwqYc,9968
-src/config.py,sha256=klWrNycPxzVt9wPhiNbjXMkB4bHZplenfWDx-3UtQac,7120
-src/mcp_manager.py,sha256=VpRdVMy1WLegC-gBnyTcBMcKzQsdIn4JIWuHf7Q40hg,4442
-src/server.py,sha256=7hwhutP0qZ_mjZfs6jcB-UNe_VyibFKl6hPyHWoa-ns,22896
-src/single_user_mcp.py,sha256=ue5UnC0nfmuLR4z87904WqH7B-0FaACFDWaBNNL7hXE,15259
-src/frontend_dist/index.html,sha256=CL9uiDUygp5_5_VpsW4WMgYFsMAfVSueYit_vFgX0Qo,673
-src/frontend_dist/assets/index-CKkid2y-.js,sha256=zaZ7j0nyGkywXAMuCrhZLaSOVqLu7JkQG3wE_8QiFT4,219537
-src/frontend_dist/assets/index-CRxojymD.css,sha256=kANM9zPkbS5aLrPzePZK0Fbt580I6kNnyFjkFH13HtA,11383
-src/middleware/data_access_tracker.py,sha256=JkwZdtMCiVU7JJZDd-GhlowW2szMDnXrD95nhxQVXR4,21165
-src/middleware/session_tracking.py,sha256=rWZh4UBQbqzPh4p6vxdtRwEC1uzq93yjzxcI9LnlRkA,19307
-open_edison-0.1.10.dist-info/METADATA,sha256=15i5EIVlRNQtBIs3RJTTwiTPXEfF2FYy2a3W2KoBN3g,8834
-open_edison-0.1.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_edison-0.1.10.dist-info/entry_points.txt,sha256=qNAkJcnoTXRhj8J--3PDmXz_TQKdB8H_0C9wiCtDIyA,72
-open_edison-0.1.10.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-open_edison-0.1.10.dist-info/RECORD,,