open-edison 0.1.16__tar.gz → 0.1.17__tar.gz

{open_edison-0.1.16 → open_edison-0.1.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-edison
-Version: 0.1.16
+Version: 0.1.17
 Summary: Open-source MCP security, aggregation, and monitoring. Single-user, self-hosted MCP proxy.
 Author-email: Hugo Berg <hugo@edison.watch>
 License-File: LICENSE
@@ -32,11 +32,27 @@ Open-source MCP security gateway that prevents data exfiltration—via direct ac
 Just want to run it?
 
 ```bash
+# Installs uv (via Astral installer) and launches open-edison with uvx.
+# Note: This does NOT install Node/npx. Install Node if you plan to use npx-based tools like mcp-remote.
 curl -fsSL https://raw.githubusercontent.com/Edison-Watch/open-edison/main/curl_pipe_bash.sh | bash
 ```
 
 Run locally with uvx: `uvx open-edison --config-dir ~/edison-config`
 
+If you need `npx` (for Node-based MCP tools like `mcp-remote`), install Node.js as well:
+
+- macOS:
+  - uv: `curl -fsSL https://astral.sh/uv/install.sh | sh`
+  - Node/npx: `brew install node`
+- Linux (Debian/Ubuntu):
+  - uv: `curl -fsSL https://astral.sh/uv/install.sh | sh`
+  - Node/npx: `sudo apt-get update && sudo apt-get install -y nodejs npm`
+- Windows (PowerShell):
+  - uv: `powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"`
+  - Node/npx: `winget install -e --id OpenJS.NodeJS`
+
+After installation, ensure that `npx` is available on PATH.
+
 <div align="center">
   <h2>📧 Interested in connecting AI to your business software with proper access controls? <a href="mailto:hello@edison.watch">Contact us</a> to discuss.</h2>
 </div>
@@ -116,7 +132,7 @@ make setup
   "server": { "host": "0.0.0.0", "port": 3000, "api_key": "..." },
   "logging": { "level": "INFO", "database_path": "sessions.db" },
   "mcp_servers": [
-    { "name": "filesystem", "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"], "enabled": true },
+    { "name": "filesystem", "command": "uvx", "args": ["mcp-server-filesystem", "/tmp"], "enabled": true },
     { "name": "github", "enabled": false, "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "..." } }
   ]
 }
@@ -134,7 +150,7 @@ The server will be available at `http://localhost:3000`.
 
 ## MCP Connection
 
-Connect any MCP client to Open Edison:
+Connect any MCP client to Open Edison (requires Node.js/npm for `npx`):
 
 ```bash
 npx -y mcp-remote http://localhost:3000/mcp/ --http-only --header "Authorization: Bearer your-api-key"

{open_edison-0.1.16 → open_edison-0.1.17}/README.md

@@ -5,11 +5,27 @@ Open-source MCP security gateway that prevents data exfiltration—via direct ac
 Just want to run it?
 
 ```bash
+# Installs uv (via Astral installer) and launches open-edison with uvx.
+# Note: This does NOT install Node/npx. Install Node if you plan to use npx-based tools like mcp-remote.
 curl -fsSL https://raw.githubusercontent.com/Edison-Watch/open-edison/main/curl_pipe_bash.sh | bash
 ```
 
 Run locally with uvx: `uvx open-edison --config-dir ~/edison-config`
 
+If you need `npx` (for Node-based MCP tools like `mcp-remote`), install Node.js as well:
+
+- macOS:
+  - uv: `curl -fsSL https://astral.sh/uv/install.sh | sh`
+  - Node/npx: `brew install node`
+- Linux (Debian/Ubuntu):
+  - uv: `curl -fsSL https://astral.sh/uv/install.sh | sh`
+  - Node/npx: `sudo apt-get update && sudo apt-get install -y nodejs npm`
+- Windows (PowerShell):
+  - uv: `powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"`
+  - Node/npx: `winget install -e --id OpenJS.NodeJS`
+
+After installation, ensure that `npx` is available on PATH.
+
 <div align="center">
   <h2>📧 Interested in connecting AI to your business software with proper access controls? <a href="mailto:hello@edison.watch">Contact us</a> to discuss.</h2>
 </div>
@@ -89,7 +105,7 @@ make setup
   "server": { "host": "0.0.0.0", "port": 3000, "api_key": "..." },
   "logging": { "level": "INFO", "database_path": "sessions.db" },
   "mcp_servers": [
-    { "name": "filesystem", "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"], "enabled": true },
+    { "name": "filesystem", "command": "uvx", "args": ["mcp-server-filesystem", "/tmp"], "enabled": true },
     { "name": "github", "enabled": false, "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "..." } }
   ]
 }
@@ -107,7 +123,7 @@ The server will be available at `http://localhost:3000`.
 
 ## MCP Connection
 
-Connect any MCP client to Open Edison:
+Connect any MCP client to Open Edison (requires Node.js/npm for `npx`):
 
 ```bash
 npx -y mcp-remote http://localhost:3000/mcp/ --http-only --header "Authorization: Bearer your-api-key"

{open_edison-0.1.16 → open_edison-0.1.17}/config.json

@@ -2,7 +2,7 @@
     "server": {
         "host": "0.0.0.0",
         "port": 3000,
-        "api_key": "dev-api-key-change-me"
+        "api_key": "dev-api-key-change-me-2"
     },
     "logging": {
         "level": "INFO",

{open_edison-0.1.16 → open_edison-0.1.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "open-edison"
-version = "0.1.16"
+version = "0.1.17"
 description = "Open-source MCP security, aggregation, and monitoring. Single-user, self-hosted MCP proxy."
 readme = "README.md"
 authors = [
@@ -39,6 +39,7 @@ dev-dependencies = [
     "ruff>=0.12.3",
     "pytest>=8.3.3",
     "pytest-asyncio>=1.0.0",
+    "vulture>=2.11",
     "twine>=5.1.1",
 ]
 
@@ -76,11 +77,9 @@ include = [
   "prompt_permissions.json",
   "src/**",
   "docs/**",
-]
-exclude = [
+  # Ensure packaged dashboard assets are present when building from sdist
   "src/frontend_dist/**",
 ]
-force-include = { "src/frontend_dist" = "src/frontend_dist" }
 
 [tool.ruff]
 line-length = 100
@@ -112,3 +111,6 @@ reportMissingTypeStubs = true
 reportUnusedFunction = false  # Disable unused function warnings since we have many dynamically registered functions
 venvPath = ".venv"
 extraPaths = ["src"]
+
+[tool.vulture]
+exclude = ["tests", "src/frontend_dist"]

{open_edison-0.1.16 → open_edison-0.1.17}/src/middleware/session_tracking.py

@@ -102,7 +102,7 @@ def create_db_session() -> Generator[Session, None, None]:
 
     # Ensure changes are flushed to the main database file (avoid WAL for sql.js compatibility)
     @event.listens_for(engine, "connect")
-    def _set_sqlite_pragmas(dbapi_connection, connection_record):  # type: ignore[no-untyped-def]
+    def _set_sqlite_pragmas(dbapi_connection, connection_record):  # type: ignore[no-untyped-def] # noqa
         cur = dbapi_connection.cursor()  # type: ignore[attr-defined]
         try:
             cur.execute("PRAGMA journal_mode=DELETE")  # type: ignore[attr-defined]

{open_edison-0.1.16 → open_edison-0.1.17}/src/server.py

@@ -6,6 +6,7 @@ No multi-user support, no complex routing - just a straightforward proxy.
 """
 
 import asyncio
+import json
 import traceback
 from collections.abc import Awaitable, Callable, Coroutine
 from pathlib import Path
@@ -23,7 +24,6 @@ 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]
-from src.mcp_manager import MCPManager
 from src.middleware.session_tracking import (
     MCPSessionModel,
     create_db_session,
@@ -57,8 +57,7 @@ class OpenEdisonProxy:
         self.port: int = port
 
         # Initialize components
-        self.mcp_manager: MCPManager = MCPManager()
-        self.single_user_mcp: SingleUserMCP = SingleUserMCP(self.mcp_manager)
+        self.single_user_mcp: SingleUserMCP = SingleUserMCP()
 
         # Initialize FastAPI app for management
         self.fastapi_app: FastAPI = self._create_fastapi_app()
@@ -184,30 +183,33 @@ class OpenEdisonProxy:
             """
             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
+            Precedence for reads and writes:
+            1) Config dir (OPEN_EDISON_CONFIG_DIR or platform default) — if file exists
+            2) Repository/package defaults next to src/ — and bootstrap a copy into the config dir if missing
+            3) Config dir target path (even if not yet created) 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
+            # 1) Config directory (preferred)
             try:
                 base = _get_cfg_dir()
             except Exception:
                 base = Path.cwd()
             target = base / filename
-            if (not target.exists()) and repo_candidate.exists():
+            if target.exists():
+                return target
+
+            # 2) Repository/package defaults next to src/
+            repo_candidate = Path(__file__).parent.parent / filename
+            if repo_candidate.exists():
+                # Bootstrap a copy into config dir when possible
                 try:
                     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 if target.exists() else repo_candidate
+                return target if target.exists() else repo_candidate
+
+            # 3) Fall back to config dir path (will be created on save)
+            return target
 
         async def _serve_json(filename: str) -> Response:  # type: ignore[override]
             if filename not in allowed_json_files:
@@ -238,23 +240,28 @@ class OpenEdisonProxy:
                 content = body.get("content", "")
                 if not isinstance(content, str):
                     raise ValueError("content must be string")
+                source: str = "unknown"
                 if isinstance(name, str) and name in allowed_json_files:
                     target = _resolve_json_path(name)
+                    source = f"name={name}"
                 elif isinstance(path_val, str):
-                    base = Path.cwd()
-                    # Normalize path but restrict to allowed filenames
+                    # Normalize path but restrict to allowed filenames, then resolve like reads
                     candidate = Path(path_val)
                     filename = candidate.name
                     if filename not in allowed_json_files:
                         raise ValueError("filename not allowed")
-                    target = base / filename
+                    target = _resolve_json_path(filename)
+                    source = f"path={path_val} -> filename={filename}"
                 else:
                     raise ValueError("invalid target file")
-                # Basic validation to ensure valid JSON
-                import json as _json
 
-                _ = _json.loads(content or "{}")
+                log.debug(
+                    f"Saving JSON config ({source}), resolved target: {target} (bytes={len(content.encode('utf-8'))})"
+                )
+
+                _ = json.loads(content or "{}")
                 target.write_text(content or "{}", encoding="utf-8")
+                log.debug(f"Saved JSON config to {target}")
                 return {"status": "ok"}
             except Exception as e:  # noqa: BLE001
                 raise HTTPException(status_code=400, detail=f"Save failed: {e}") from e
@@ -348,12 +355,6 @@ class OpenEdisonProxy:
         log.info("🚀 Starting both FastAPI and FastMCP servers...")
         _ = await asyncio.gather(*servers_to_run)
 
-    async def shutdown(self) -> None:
-        """Shutdown the proxy server and all MCP servers"""
-        log.info("🛑 Shutting down Open Edison proxy server")
-        await self.mcp_manager.shutdown()
-        log.info("✅ Open Edison proxy server shutdown complete")
-
     def _register_routes(self, app: FastAPI) -> None:
         """Register all routes for the FastAPI app"""
         # Register routes with their decorators
@@ -364,48 +365,18 @@ class OpenEdisonProxy:
             methods=["GET"],
             dependencies=[Depends(self.verify_api_key)],
         )
-        app.add_api_route(
-            "/mcp/{server_name}/start",
-            self.start_mcp_server,
-            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,
-            methods=["POST"],
-            dependencies=[Depends(self.verify_api_key)],
-        )
-        app.add_api_route(
-            "/mcp/call",
-            self.proxy_mcp_call,
-            methods=["POST"],
-            dependencies=[Depends(self.verify_api_key)],
-        )
         app.add_api_route(
             "/mcp/mounted",
             self.get_mounted_servers,
             methods=["GET"],
             dependencies=[Depends(self.verify_api_key)],
         )
-        app.add_api_route(
-            "/mcp/{server_name}/mount",
-            self.mount_server,
-            methods=["POST"],
-            dependencies=[Depends(self.verify_api_key)],
-        )
-        app.add_api_route(
-            "/mcp/{server_name}/unmount",
-            self.unmount_server,
-            methods=["POST"],
-            dependencies=[Depends(self.verify_api_key)],
-        )
         # Public sessions endpoint (no auth) for simple local dashboard
         app.add_api_route(
             "/sessions",
@@ -426,6 +397,18 @@ class OpenEdisonProxy:
             raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid API key")
         return credentials.credentials
 
+    async def mcp_status(self) -> dict[str, list[dict[str, Any]]]:
+        """Get status of configured MCP servers (auth required)."""
+        return {
+            "servers": [
+                {
+                    "name": server.name,
+                    "enabled": server.enabled,
+                }
+                for server in config.mcp_servers
+            ]
+        }
+
     def _handle_server_operation_error(
         self, operation: str, server_name: str, error: Exception
     ) -> HTTPException:
@@ -451,63 +434,6 @@ class OpenEdisonProxy:
         """Health check endpoint"""
         return {"status": "healthy", "version": "0.1.0", "mcp_servers": len(config.mcp_servers)}
 
-    async def mcp_status(self) -> dict[str, list[dict[str, str | bool]]]:
-        """Get status of configured MCP servers"""
-        return {
-            "servers": [
-                {
-                    "name": server.name,
-                    "enabled": server.enabled,
-                    "running": await self.mcp_manager.is_server_running(server.name),
-                }
-                for server in config.mcp_servers
-            ]
-        }
-
-    async def start_mcp_server(self, server_name: str) -> dict[str, str]:
-        """Start a specific MCP server"""
-        try:
-            _ = await self.mcp_manager.start_server(server_name)
-            return {"message": f"Server {server_name} started successfully"}
-        except Exception as e:
-            raise self._handle_server_operation_error("start", server_name, e) from e
-
-    async def stop_mcp_server(self, server_name: str) -> dict[str, str]:
-        """Stop a specific MCP server"""
-        try:
-            await self.mcp_manager.stop_server(server_name)
-            return {"message": f"Server {server_name} stopped successfully"}
-        except Exception as e:
-            raise self._handle_server_operation_error("stop", server_name, e) from e
-
-    async def proxy_mcp_call(self, request: dict[str, Any]) -> dict[str, Any]:
-        """
-        Proxy MCP calls to mounted servers.
-
-        This now routes requests through the mounted FastMCP servers.
-        """
-        try:
-            log.info(f"Proxying MCP request: {request.get('method', 'unknown')}")
-
-            mounted = await self.single_user_mcp.get_mounted_servers()
-            mounted_names = [server["name"] for server in mounted]
-
-            return {
-                "jsonrpc": "2.0",
-                "id": request.get("id"),
-                "result": {
-                    "message": "MCP request routed through FastMCP",
-                    "request": request,
-                    "mounted_servers": mounted_names,
-                },
-            }
-        except Exception as e:
-            log.error(f"Failed to proxy MCP call: {e}")
-            raise HTTPException(
-                status_code=500,
-                detail=f"Failed to proxy MCP call: {str(e)}",
-            ) from e
-
     async def get_mounted_servers(self) -> dict[str, Any]:
         """Get list of currently mounted MCP servers."""
         try:
@@ -520,36 +446,6 @@ class OpenEdisonProxy:
                 detail=f"Failed to get mounted servers: {str(e)}",
             ) from e
 
-    async def mount_server(self, server_name: str) -> dict[str, str]:
-        """Mount a specific MCP server."""
-        try:
-            server_config = self._find_server_config(server_name)
-            success = await self.single_user_mcp.mount_server(server_config)
-            if success:
-                return {"message": f"Server {server_name} mounted successfully"}
-            raise HTTPException(
-                status_code=500,
-                detail=f"Failed to mount server: {server_name}",
-            )
-        except HTTPException:
-            raise
-        except Exception as e:
-            raise self._handle_server_operation_error("mount", server_name, e) from e
-
-    async def unmount_server(self, server_name: str) -> dict[str, str]:
-        """Unmount a specific MCP server."""
-        try:
-            if server_name == "test-echo":
-                log.info("Special handling for test-echo server unmount")
-                _ = await self.single_user_mcp.unmount_server(server_name)
-                return {"message": f"Server {server_name} unmounted successfully"}
-            _ = await self.single_user_mcp.unmount_server(server_name)
-            return {"message": f"Server {server_name} unmounted successfully"}
-        except HTTPException:
-            raise
-        except Exception as e:
-            raise self._handle_server_operation_error("unmount", server_name, e) from e
-
     async def get_sessions(self) -> dict[str, Any]:
         """Return recent MCP session summaries from local SQLite.
 

{open_edison-0.1.16 → open_edison-0.1.17}/src/single_user_mcp.py

@@ -11,7 +11,6 @@ from fastmcp import FastMCP
 from loguru import logger as log
 
 from src.config import MCPServerConfig, config
-from src.mcp_manager import MCPManager
 from src.middleware.session_tracking import (
     SessionTrackingMiddleware,
     get_current_session_data_tracker,
@@ -42,9 +41,8 @@ class SingleUserMCP(FastMCP[Any]):
     All enabled MCP servers are mounted through a single FastMCP composite proxy.
     """
 
-    def __init__(self, mcp_manager: MCPManager):
+    def __init__(self):
         super().__init__(name="open-edison-single-user")
-        self.mcp_manager: MCPManager = mcp_manager
         self.mounted_servers: dict[str, MountedServerInfo] = {}
         self.composite_proxy: FastMCP[Any] | None = None
 
@@ -110,21 +108,12 @@ class SingleUserMCP(FastMCP[Any]):
             True if composite proxy was created successfully, False otherwise
         """
         try:
-            # Filter out test servers for composite proxy
-            real_servers = [s for s in enabled_servers if s.command != "echo"]
-
-            if not real_servers:
+            if not enabled_servers:
                 log.info("No real servers to mount in composite proxy")
                 return True
 
-            # Start all required server processes
-            for server_config in real_servers:
-                if not await self.mcp_manager.is_server_running(server_config.name):
-                    log.info(f"Starting server process: {server_config.name}")
-                    _ = await self.mcp_manager.start_server(server_config.name)
-
             # Convert to FastMCP config format
-            fastmcp_config = self._convert_to_fastmcp_config(real_servers)
+            fastmcp_config = self._convert_to_fastmcp_config(enabled_servers)
 
             log.info(
                 f"Creating composite proxy for servers: {list(fastmcp_config['mcpServers'].keys())}"
@@ -140,12 +129,12 @@ class SingleUserMCP(FastMCP[Any]):
             await self.import_server(self.composite_proxy)
 
             # Track mounted servers for status reporting
-            for server_config in real_servers:
+            for server_config in enabled_servers:
                 self.mounted_servers[server_config.name] = MountedServerInfo(
                     config=server_config, proxy=self.composite_proxy
                 )
 
-            log.info(f"✅ Created composite proxy with {len(real_servers)} servers")
+            log.info(f"✅ Created composite proxy with {len(enabled_servers)} servers")
             return True
 
         except Exception as e:
@@ -221,7 +210,6 @@ class SingleUserMCP(FastMCP[Any]):
         try:
             # Remove from mounted servers
             await self._cleanup_mounted_server(excluded_server)
-            await self._stop_server_process(excluded_server)
 
             # Get remaining servers that should be in composite proxy
             remaining_configs = [
@@ -249,11 +237,6 @@ class SingleUserMCP(FastMCP[Any]):
             del self.mounted_servers[server_name]
             log.info(f"✅ Unmounted MCP server: {server_name}")
 
-    async def _stop_server_process(self, server_name: str) -> None:
-        """Stop the server subprocess if it's not a test server."""
-        if server_name != "test-echo":
-            await self.mcp_manager.stop_server(server_name)
-
     async def get_mounted_servers(self) -> list[ServerStatusInfo]:
         """Get list of currently mounted servers."""
         return [

{open_edison-0.1.16 → open_edison-0.1.17}/src/telemetry.py

@@ -22,6 +22,7 @@ from __future__ import annotations
 
 import json
 import os
+import platform
 import traceback
 import uuid
 from collections.abc import Callable
@@ -175,12 +176,27 @@ def initialize_telemetry(override: TelemetryConfig | None = None) -> None:  # no
 
     # Provider/meter
     try:
+        # Capture platform/runtime details
+        install_id = _ensure_install_id()
+        os_type = platform.system().lower() or "unknown"
+        os_description = platform.platform()
+        host_arch = platform.machine()
+        runtime_version = platform.python_version()
+        service_version = getattr(config, "version", "unknown")
+
         # Attach a resource so metrics include service identifiers
         resource = Resource.create(
             {
                 "service.name": "open-edison",
                 "service.namespace": "open-edison",
+                "service.version": service_version,
+                "service.instance.id": install_id,
                 "telemetry.sdk.language": "python",
+                "os.type": os_type,
+                "os.description": os_description,
+                "host.arch": host_arch,
+                "process.runtime.name": "python",
+                "process.runtime.version": runtime_version,
             }
         )
         provider: Any = ot_sdk_metrics.MeterProvider(metric_readers=[reader], resource=resource)
@@ -209,7 +225,7 @@ def initialize_telemetry(override: TelemetryConfig | None = None) -> None:  # no
         log.error("Metrics instrument creation failed\n{}", traceback.format_exc())
         return
 
-    _ = _ensure_install_id()
+    _ = install_id
     _initialized = True
     log.info("📈 Telemetry initialized")