open-edison 0.1.41__tar.gz → 0.1.43__tar.gz

{open_edison-0.1.41 → open_edison-0.1.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-edison
-Version: 0.1.41
+Version: 0.1.43
 Summary: Open-source MCP security, aggregation, and monitoring. Single-user, self-hosted MCP proxy.
 Author-email: Hugo Berg <hugo@edison.watch>
 License-File: LICENSE

{open_edison-0.1.41 → open_edison-0.1.43}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "open-edison"
-version = "0.1.41"
+version = "0.1.43"
 description = "Open-source MCP security, aggregation, and monitoring. Single-user, self-hosted MCP proxy."
 readme = "README.md"
 authors = [
@@ -64,7 +64,6 @@ include = [
   "prompt_permissions.json",
   "docs/**",
 ]
-force-include = { "src/frontend_dist" = "frontend_dist" }
 
 [tool.hatch.build.targets.wheel.hooks.custom]
 path = "hatch_build.py"

{open_edison-0.1.41 → open_edison-0.1.43}/src/cli.py

@@ -8,15 +8,15 @@ import argparse
 import asyncio
 import os
 import subprocess as _subprocess
-import sys
 from contextlib import suppress
 from pathlib import Path
-from typing import Any, NoReturn, cast
+from typing import Any, NoReturn
 
 from loguru import logger as _log  # type: ignore[reportMissingImports]
 
-from .config import Config, get_config_dir, get_config_json_path
-from .server import OpenEdisonProxy
+from src.config import Config, get_config_dir, get_config_json_path
+from src.mcp_importer.cli import run_cli
+from src.server import OpenEdisonProxy
 
 log: Any = _log
 
@@ -220,35 +220,8 @@ def main(argv: list[str] | None = None) -> NoReturn:  # noqa: C901
         raise SystemExit(exit_code)
 
     if getattr(args, "command", None) == "import-mcp":
-        # Defer-import importer package (lives under repository scripts/)
-        importer_pkg = Path(__file__).parent.parent / "scripts" / "mcp_importer"
-        try:
-            if str(importer_pkg) not in sys.path:
-                sys.path.insert(0, str(importer_pkg))
-            from mcp_importer.cli import run_cli  # type: ignore
-        except Exception as imp_exc:  # noqa: BLE001
-            log.error(
-                "Failed to load MCP importer package from {}: {}",
-                importer_pkg,
-                imp_exc,
-            )
-            raise SystemExit(1) from imp_exc
-
-        importer_argv: list[str] = []
-        if args.source:
-            importer_argv += ["--source", str(args.source)]
-        if getattr(args, "config_dir", None):
-            importer_argv += [
-                "--config-dir",
-                str(Path(args.config_dir).expanduser().resolve()),
-            ]
-        if args.merge:
-            importer_argv += ["--merge", str(args.merge)]
-        if bool(getattr(args, "dry_run", False)):
-            importer_argv += ["--dry-run"]
-
-        rc_val: int = int(cast(Any, run_cli)(importer_argv))
-        raise SystemExit(rc_val)
+        result_code = run_cli(argv)
+        raise SystemExit(result_code)
 
     # default: run server (top-level flags)
     try:

{open_edison-0.1.41 → open_edison-0.1.43}/src/mcp_importer/api.py

@@ -3,9 +3,10 @@ import asyncio
 from collections.abc import Awaitable
 from enum import Enum
 from pathlib import Path
-from typing import Any, Protocol, cast, runtime_checkable
+from typing import Any
 
 from fastmcp import FastMCP
+from loguru import logger as log
 
 from src.config import Config, MCPServerConfig, get_config_json_path
 from src.mcp_importer import paths as _paths
@@ -24,14 +25,6 @@ from src.mcp_importer.merge import MergePolicy, merge_servers
 from src.oauth_manager import OAuthStatus, get_oauth_manager
 
 
-@runtime_checkable
-class _MCPClientLike(Protocol):
-    async def list_tools(self) -> Any: ...
-    async def list_resources(self) -> Any: ...
-    async def list_prompts(self) -> Any: ...
-    def shutdown(self) -> Awaitable[Any] | Any: ...
-
-
 class CLIENT(str, Enum):
     CURSOR = "cursor"
     VSCODE = "vscode"
@@ -144,6 +137,7 @@ def verify_mcp_server(server: MCPServerConfig) -> bool:  # noqa
         if not server.command.strip():
             return False
 
+        # Inline backend config and capability listing (no extra helpers)
         backend_cfg: dict[str, Any] = {
             "mcpServers": {
                 server.name: {
@@ -156,26 +150,40 @@ def verify_mcp_server(server: MCPServerConfig) -> bool:  # noqa
         }
 
         proxy: FastMCP[Any] | None = None
+        host: FastMCP[Any] | None = None
         try:
-            proxy = FastMCP.as_proxy(backend=backend_cfg, name=f"open-edison-verify-{server.name}")
-            s: _MCPClientLike = cast(_MCPClientLike, proxy)
+            proxy = FastMCP.as_proxy(backend_cfg)
+            host = FastMCP(name=f"open-edison-verify-host-{server.name}")
+            host.mount(proxy, prefix=server.name)
+
+            async def _call_list(kind: str) -> Any:
+                manager_name = {
+                    "tools": "_tool_manager",
+                    "resources": "_resource_manager",
+                    "prompts": "_prompt_manager",
+                }[kind]
+                manager = getattr(host, manager_name)
+                return await getattr(manager, f"list_{kind}")()
+
             await asyncio.wait_for(
                 asyncio.gather(
-                    s.list_tools(),
-                    s.list_resources(),
-                    s.list_prompts(),
+                    _call_list("tools"),
+                    _call_list("resources"),
+                    _call_list("prompts"),
                 ),
-                timeout=15.0,
+                timeout=30.0,
             )
             return True
-        except Exception:
+        except Exception as e:
+            log.error("MCP verification failed for '{}': {}", server.name, e)
             return False
         finally:
             try:
-                if isinstance(proxy, FastMCP):
-                    result = proxy.shutdown()  # type: ignore[attr-defined]
-                    if isinstance(result, Awaitable):
-                        await result  # type: ignore[func-returns-value]
+                for obj in (host, proxy):
+                    if isinstance(obj, FastMCP):
+                        result = obj.shutdown()  # type: ignore[attr-defined]
+                        if isinstance(result, Awaitable):
+                            await result  # type: ignore[func-returns-value]
             except Exception:
                 pass