PyPI - open-edison - Versions diffs - 0.1.44__py3-none-any.whl → 0.1.72rc1__py3-none-any.whl - Mend

open-edison 0.1.44py3-none-any.whl → 0.1.72rc1py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (34) hide show

{open_edison-0.1.44.dist-info → open_edison-0.1.72rc1.dist-info}/METADATA +2 -21
open_edison-0.1.72rc1.dist-info/RECORD +41 -0
src/cli.py +30 -113
src/config.py +30 -9
src/events.py +5 -2
src/frontend_dist/assets/index-D05VN_1l.css +1 -0
src/frontend_dist/assets/index-D6ziuTsl.js +51 -0
src/frontend_dist/index.html +2 -2
src/frontend_dist/sw.js +22 -2
src/mcp_importer/__main__.py +0 -2
src/mcp_importer/api.py +254 -44
src/mcp_importer/export_cli.py +2 -2
src/mcp_importer/exporters.py +1 -1
src/mcp_importer/import_api.py +0 -2
src/mcp_importer/parsers.py +47 -9
src/mcp_importer/quick_cli.py +0 -2
src/mcp_importer/types.py +0 -2
src/mcp_stdio_capture.py +144 -0
src/middleware/data_access_tracker.py +49 -4
src/middleware/session_tracking.py +123 -34
src/oauth_manager.py +5 -3
src/oauth_override.py +10 -0
src/permissions.py +110 -10
src/server.py +57 -16
src/setup_tui/main.py +160 -21
src/single_user_mcp.py +246 -105
src/tools/io.py +35 -0
src/vulture_whitelist.py +3 -0
open_edison-0.1.44.dist-info/RECORD +0 -37
src/frontend_dist/assets/index-BUUcUfTt.js +0 -51
src/frontend_dist/assets/index-o6_8mdM8.css +0 -1
{open_edison-0.1.44.dist-info → open_edison-0.1.72rc1.dist-info}/WHEEL +0 -0
{open_edison-0.1.44.dist-info → open_edison-0.1.72rc1.dist-info}/entry_points.txt +0 -0
{open_edison-0.1.44.dist-info → open_edison-0.1.72rc1.dist-info}/licenses/LICENSE +0 -0

src/frontend_dist/index.html CHANGED Viewed

@@ -10,8 +10,8 @@
         const prefersLight = window.matchMedia && window.matchMedia('(prefers-color-scheme: light)').matches;
         document.documentElement.setAttribute('data-theme', prefersLight ? 'light' : 'dark');
     </script>
-  <script type="module" crossorigin src="/assets/index-BUUcUfTt.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-o6_8mdM8.css">
+  <script type="module" crossorigin src="/assets/index-D6ziuTsl.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-D05VN_1l.css">
 </head>
 <body>

src/frontend_dist/sw.js CHANGED Viewed

@@ -61,8 +61,28 @@ self.addEventListener('notificationclick', (event) => {
             return;
         }
-        // Generic click: open dashboard as a safe fallback
-        event.waitUntil(self.clients.openWindow('/dashboard').catch(() => { }));
+        // Generic click: focus existing dashboard tab; if not found, open one with URL params so it can enqueue the pending approval
+        event.waitUntil((async () => {
+            try {
+                const allClients = await self.clients.matchAll({ type: 'window', includeUncontrolled: true });
+                const base = self.location && self.location.origin ? self.location.origin : '';
+                const targetPrefix = base + '/dashboard';
+                const existing = allClients.find(c => c.url && c.url.startsWith(targetPrefix));
+                if (existing) {
+                    try { existing.postMessage({ type: 'MCP_ENQUEUE_PENDING', data: payload }); } catch (e) { /* ignore */ }
+                    await existing.focus();
+                    return;
+                }
+            } catch (e) { /* ignore */ }
+            try {
+                const params = new URLSearchParams();
+                if (payload.sessionId) params.set('pa_s', payload.sessionId);
+                if (payload.kind) params.set('pa_k', payload.kind);
+                if (payload.name) params.set('pa_n', payload.name);
+                const url = '/dashboard/?' + params.toString();
+                await self.clients.openWindow(url);
+            } catch (e) { /* ignore */ }
+        })());
     } catch (e) {
         // swallow
     }

src/mcp_importer/__main__.py CHANGED Viewed

@@ -1,5 +1,3 @@
-from __future__ import annotations
 import sys
 from src.mcp_importer.cli import run_cli as import_run_cli

src/mcp_importer/api.py CHANGED Viewed

@@ -1,12 +1,15 @@
 # pyright: reportMissingImports=false, reportUnknownVariableType=false, reportUnknownMemberType=false, reportUnknownArgumentType=false, reportUnknownParameterType=false
 import asyncio
-from collections.abc import Awaitable
+import contextlib
 from enum import Enum
 from pathlib import Path
 from typing import Any
+import questionary
+from fastmcp import Client as FastMCPClient
 from fastmcp import FastMCP
-from loguru import logger as log
+from fastmcp.client.auth.oauth import FileTokenStorage
+from loguru import logger as log  # kept for non-TUI contexts; printing used in TUI flows
 from src.config import Config, MCPServerConfig, get_config_json_path
 from src.mcp_importer import paths as _paths
@@ -23,6 +26,8 @@ from src.mcp_importer.importers import (
 )
 from src.mcp_importer.merge import MergePolicy, merge_servers
 from src.oauth_manager import OAuthStatus, get_oauth_manager
+from src.oauth_override import OpenEdisonOAuth
+from src.tools.io import suppress_fds
 class CLIENT(str, Enum):
@@ -133,12 +138,140 @@ def export_edison_to(
 def verify_mcp_server(server: MCPServerConfig) -> bool:  # noqa
     """Minimal validation: try listing tools/resources/prompts via FastMCP within a timeout."""
-    async def _verify_async() -> bool:
+    async def _verify_async() -> bool:  # noqa: C901
         if not server.command.strip():
             return False
+        oauth_info = None
-        # Inline backend config and capability listing (no extra helpers)
-        backend_cfg: dict[str, Any] = {
+        # If this is a remote server, consult OAuth requirement first. Only skip
+        # verification when OAuth is actually required and no tokens are present.
+        if server.is_remote_server():
+            remote_url: str | None = server.get_remote_url()
+            if remote_url:
+                oauth_info = await get_oauth_manager().check_oauth_requirement(
+                    server.name, remote_url
+                )
+                if oauth_info.status != OAuthStatus.NOT_REQUIRED:
+                    # Token presence check
+                    storage = FileTokenStorage(
+                        server_url=remote_url, cache_dir=get_oauth_manager().cache_dir
+                    )
+                    tokens = await storage.get_tokens()
+                    no_tokens: bool = not tokens or (
+                        not getattr(tokens, "access_token", None)
+                        and not getattr(tokens, "refresh_token", None)
+                    )
+                    # Detect if inline headers are present in args (translated from config)
+                    has_inline_headers: bool = any(
+                        (a == "--header" or a.startswith("--header")) for a in server.args
+                    )
+                    if (
+                        oauth_info.status == OAuthStatus.NEEDS_AUTH
+                        and no_tokens
+                        and not has_inline_headers
+                    ):
+                        questionary.print(
+                            f"Skipping verification for remote server '{server.name}' pending OAuth",
+                            style="bold fg:ansiyellow",
+                        )
+                        return True
+        # Remote servers
+        if server.is_remote_server():
+            connection_timeout = 10.0
+            remote_url = server.get_remote_url()
+            if remote_url:
+                # If inline headers are specified (e.g., API key), verify via proxy to honor headers
+                has_inline_headers_remote: bool = any(
+                    (a == "--header" or a.startswith("--header")) for a in server.args
+                )
+                if has_inline_headers_remote:
+                    backend_cfg_remote: dict[str, Any] = {
+                        "mcpServers": {
+                            server.name: {
+                                "command": server.command,
+                                "args": server.args,
+                                "env": server.env or {},
+                                **({"roots": server.roots} if server.roots else {}),
+                            }
+                        }
+                    }
+                    proxy_remote: FastMCP[Any] | None = None
+                    host_remote: FastMCP[Any] | None = None
+                    try:
+                        # TODO: In debug mode, do not suppress child process output.
+                        with suppress_fds(suppress_stdout=True, suppress_stderr=True):
+                            proxy_remote = FastMCP.as_proxy(backend_cfg_remote)
+                            host_remote = FastMCP(name=f"open-edison-verify-host-{server.name}")
+                            host_remote.mount(proxy_remote, prefix=server.name)
+                            async def _list_tools_only() -> Any:
+                                return await host_remote._tool_manager.list_tools()  # type: ignore[attr-defined]
+                            await asyncio.wait_for(_list_tools_only(), timeout=10.0)
+                        return True
+                    except Exception as e:
+                        log.error(
+                            "MCP remote (headers) verification failed for '{}': {}", server.name, e
+                        )
+                        return False
+                    finally:
+                        for obj in (host_remote, proxy_remote):
+                            if isinstance(obj, FastMCP):
+                                with contextlib.suppress(Exception):
+                                    result = obj.shutdown()  # type: ignore[attr-defined]
+                                    await asyncio.wait_for(result, timeout=2.0)  # type: ignore[func-returns-value]
+                # Otherwise, avoid triggering OAuth flows during verification
+                ping_succeeded = False
+                try:
+                    if oauth_info is None:
+                        oauth_info = await get_oauth_manager().check_oauth_requirement(
+                            server.name, remote_url
+                        )
+                    # If OAuth is needed or we are already authenticated, don't initiate browser flows here
+                    if oauth_info.status in (OAuthStatus.NEEDS_AUTH, OAuthStatus.AUTHENTICATED):
+                        return True
+                    # NOT_REQUIRED: quick unauthenticated ping
+                    # TODO: In debug mode, do not suppress child process output.
+                    questionary.print(
+                        f"Testing connection to '{server.name}'... (timeout: {connection_timeout}s)",
+                        style="bold fg:ansigreen",
+                    )
+                    log.debug(f"Establishing contact with remote server '{server.name}'")
+                    async with asyncio.timeout(connection_timeout):
+                        async with FastMCPClient(
+                            remote_url,
+                            auth=None,
+                            timeout=connection_timeout,
+                            init_timeout=connection_timeout,
+                        ) as client:
+                            log.debug(f"Connection established to '{server.name}'; pinging...")
+                            with suppress_fds(suppress_stdout=True, suppress_stderr=True):
+                                await asyncio.wait_for(fut=client.ping(), timeout=1.0)
+                            log.info(f"Ping received from '{server.name}'; shutting down client")
+                            ping_succeeded = True
+                        log.debug(f"Client '{server.name}' shut down")
+                    return ping_succeeded
+                except TimeoutError:
+                    if ping_succeeded:
+                        questionary.print(
+                            f"Ping received from '{server.name}' but shutdown timed out (treating as success)",
+                            style="bold fg:ansiyellow",
+                        )
+                    else:
+                        questionary.print(
+                            f"Verification timed out (> {connection_timeout}s) for '{server.name}'",
+                            style="bold fg:ansired",
+                        )
+                    return ping_succeeded
+                except Exception as e:  # noqa: BLE001
+                    questionary.print(
+                        f"Verification failed for '{server.name}': {e}", style="bold fg:ansired"
+                    )
+                    return False
+        # Local/stdio servers: mount via proxy and perform a single light operation (tools only)
+        backend_cfg_local: dict[str, Any] = {
             "mcpServers": {
                 server.name: {
                     "command": server.command,
@@ -149,56 +282,133 @@ def verify_mcp_server(server: MCPServerConfig) -> bool:  # noqa
             }
         }
-        proxy: FastMCP[Any] | None = None
-        host: FastMCP[Any] | None = None
+        proxy_local: FastMCP[Any] | None = None
+        host_local: FastMCP[Any] | None = None
         try:
-            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(
-                    _call_list("tools"),
-                    _call_list("resources"),
-                    _call_list("prompts"),
-                ),
-                timeout=30.0,
-            )
+            # TODO: In debug mode, do not suppress child process output.
+            log.info("Checking properties of '{}'...", server.name)
+            with suppress_fds(suppress_stdout=True, suppress_stderr=True):
+                proxy_local = FastMCP.as_proxy(backend_cfg_local)
+                host_local = FastMCP(name=f"open-edison-verify-host-{server.name}")
+                host_local.mount(proxy_local, prefix=server.name)
+            log.info("MCP properties check succeeded for '{}'", server.name)
+            async def _list_tools_only() -> Any:
+                return await host_local._tool_manager.list_tools()  # type: ignore[attr-defined]
+            await asyncio.wait_for(_list_tools_only(), timeout=30.0)
             return True
         except Exception as e:
-            log.error("MCP verification failed for '{}': {}", server.name, e)
+            questionary.print(
+                f"Verification failed for '{server.name}': {e}", style="bold fg:ansired"
+            )
             return False
         finally:
-            try:
-                for obj in (host, proxy):
-                    if isinstance(obj, FastMCP):
+            for obj in (host_local, proxy_local):
+                if isinstance(obj, FastMCP):
+                    with contextlib.suppress(Exception):
                         result = obj.shutdown()  # type: ignore[attr-defined]
-                        if isinstance(result, Awaitable):
-                            await result  # type: ignore[func-returns-value]
-            except Exception:
-                pass
+                        await asyncio.wait_for(result, timeout=2.0)  # type: ignore[func-returns-value]
     return asyncio.run(_verify_async())
-def server_needs_oauth(server: MCPServerConfig) -> bool:  # noqa
-    """Return True if the remote server currently needs OAuth; False otherwise."""
+def authorize_server_oauth(server: MCPServerConfig) -> bool:
+    """Run an interactive OAuth flow for a remote MCP server and cache tokens.
+    Returns True if authorization succeeded (tokens cached and a ping succeeded),
+    False otherwise. Local servers return True immediately.
+    """
-    async def _needs_oauth_async() -> bool:
+    async def _authorize_async() -> bool:
         if not server.is_remote_server():
+            return True
+        remote_url: str | None = server.get_remote_url()
+        if not remote_url:
+            log.error("OAuth requested for remote server '{}' but no URL found", server.name)
+            return False
+        oauth_manager = get_oauth_manager()
+        try:
+            # Debug info prior to starting OAuth
+            print(
+                "[OAuth] Starting authorization",
+                f"server={server.name}",
+                f"remote_url={remote_url}",
+                f"cache_dir={oauth_manager.cache_dir}",
+                f"scopes={server.oauth_scopes}",
+                f"client_name={server.oauth_client_name or 'Open Edison Setup'}",
+            )
+            oauth = OpenEdisonOAuth(
+                mcp_url=remote_url,
+                scopes=server.oauth_scopes,
+                client_name=server.oauth_client_name or "Open Edison Setup",
+                token_storage_cache_dir=oauth_manager.cache_dir,
+                callback_port=50001,
+            )
+            # Establish a connection to trigger OAuth if needed
+            async with FastMCPClient(remote_url, auth=oauth) as client:  # type: ignore
+                log.info(
+                    "Starting OAuth flow for '{}' (a browser window may open; if not, follow the printed URL)",
+                    server.name,
+                )
+                await client.ping()
+            # Refresh cached status
+            info = await oauth_manager.check_oauth_requirement(server.name, remote_url)
+            # Post-authorization token inspection (no secrets printed)
+            try:
+                storage = FileTokenStorage(server_url=remote_url, cache_dir=oauth_manager.cache_dir)
+                tokens = await storage.get_tokens()
+                access_present = bool(getattr(tokens, "access_token", None)) if tokens else False
+                refresh_present = bool(getattr(tokens, "refresh_token", None)) if tokens else False
+                expires_at = getattr(tokens, "expires_at", None) if tokens else None
+                print(
+                    "[OAuth] Authorization result:",
+                    f"status={info.status.value}",
+                    f"has_refresh_token={info.has_refresh_token}",
+                    f"token_expires_at={info.token_expires_at or expires_at}",
+                    f"tokens_cached=access:{access_present}/refresh:{refresh_present}",
+                )
+            except Exception as _e:  # noqa: BLE001
+                print("[OAuth] Authorization completed, but token inspection failed:", _e)
+            log.info("OAuth completed and tokens cached for '{}'", server.name)
+            return True
+        except Exception as e:  # noqa: BLE001
+            log.error("OAuth authorization failed for '{}': {}", server.name, e)
+            print("[OAuth] Authorization failed:", e)
+            return False
+    return asyncio.run(_authorize_async())
+def has_oauth_tokens(server: MCPServerConfig) -> bool:
+    """Return True if cached OAuth tokens exist for the remote server.
+    Local servers return True (no OAuth needed).
+    """
+    async def _check_async() -> bool:
+        if not server.is_remote_server():
+            return True
+        remote_url: str | None = server.get_remote_url()
+        if not remote_url:
+            return False
+        try:
+            storage = FileTokenStorage(
+                server_url=remote_url, cache_dir=get_oauth_manager().cache_dir
+            )
+            tokens = await storage.get_tokens()
+            return bool(tokens and (tokens.access_token or tokens.refresh_token))
+        except Exception:
             return False
-        info = await get_oauth_manager().check_oauth_requirement(
-            server.name, server.get_remote_url()
-        )
-        return info.status == OAuthStatus.NEEDS_AUTH
-    return asyncio.run(_needs_oauth_async())
+    return asyncio.run(_check_async())

src/mcp_importer/export_cli.py CHANGED Viewed

@@ -5,8 +5,10 @@ from loguru import logger as log
 from .exporters import ExportError, export_to_claude_code, export_to_cursor, export_to_vscode
 from .paths import (
+    detect_claude_code_config_path,
     detect_cursor_config_path,
     detect_vscode_config_path,
+    get_default_claude_code_config_path,
     get_default_cursor_config_path,
     get_default_vscode_config_path,
 )
@@ -135,8 +137,6 @@ def _handle_vscode(args: argparse.Namespace) -> int:
 def _handle_claude_code(args: argparse.Namespace) -> int:
-    from .paths import detect_claude_code_config_path, get_default_claude_code_config_path
     detected = detect_claude_code_config_path()
     target_path: Path = detected if detected else get_default_claude_code_config_path()

src/mcp_importer/exporters.py CHANGED Viewed

@@ -300,7 +300,7 @@ def export_to_vscode(
     # Build the minimal config
     new_config: dict[str, Any] = {
-        "mcpServers": _build_open_edison_server(name=server_name, url=url, api_key=api_key)
+        "servers": _build_open_edison_server(name=server_name, url=url, api_key=api_key)
     }
     # If already configured exactly as desired and not forcing, no-op

src/mcp_importer/import_api.py CHANGED Viewed

@@ -1,3 +1 @@
-from __future__ import annotations
 # legacy helpers were removed to satisfy deadcode scanning

src/mcp_importer/parsers.py CHANGED Viewed

@@ -1,6 +1,7 @@
 # pyright: reportUnknownArgumentType=false, reportUnknownVariableType=false, reportMissingImports=false, reportUnknownMemberType=false
 import json
+import shlex
 from pathlib import Path
 from typing import Any, cast
@@ -50,7 +51,7 @@ def safe_read_json(path: Path) -> dict[str, Any]:
     return data
-def _coerce_server_entry(name: str, node: dict[str, Any], default_enabled: bool) -> Any:
+def _coerce_server_entry(name: str, node: dict[str, Any], default_enabled: bool) -> Any:  # noqa: C901
     command_val = node.get("command", "")
     command = str(command_val) if isinstance(command_val, str) else ""
@@ -67,12 +68,35 @@ def _coerce_server_entry(name: str, node: dict[str, Any], default_enabled: bool)
     args: list[str] = [str(a) for a in args_raw]
+    # If command is provided as a full string with flags, split into program + args
+    if command and (" " in command or command.endswith(("\t", "\n"))):
+        try:
+            parts = shlex.split(command)
+            if parts:
+                command = parts[0]
+                # Prepend split args before any provided args to preserve order
+                args = parts[1:] + args
+        except Exception:
+            # If shlex fails, keep original command/args
+            pass
     env_raw = node.get("env") or node.get("environment") or {}
     env: dict[str, str] = {}
     if isinstance(env_raw, dict):
         for k, v in env_raw.items():
             env[str(k)] = str(v)
+    # Support Cursor-style remote config: { "url": "...", "headers": {...} }
+    # Translate to `npx mcp-remote <url> [--header Key: Value]*` so downstream verification works.
+    url_val = node.get("url")
+    if isinstance(url_val, str) and url_val:
+        command = "npx"
+        args = ["-y", "mcp-remote", url_val]
+        headers_raw = node.get("headers")
+        if isinstance(headers_raw, dict):
+            for hk, hv in headers_raw.items():
+                args.extend(["--header", f"{str(hk)}: {str(hv)}"])
     enabled = bool(node.get("enabled", default_enabled))
     roots_raw = node.get("roots") or node.get("rootPaths") or []
@@ -135,14 +159,28 @@ def _collect_nested(data: dict[str, Any], default_enabled: bool) -> list[Any]:
     return results
-def parse_mcp_like_json(data: dict[str, Any], default_enabled: bool = True) -> list[Any]:
+def deduplicate_by_name(servers: list[MCPServerConfig]) -> list[MCPServerConfig]:
+    result: list[MCPServerConfig] = []
+    names = set()
+    for server in servers:
+        if server.name not in names:
+            names.add(server.name)
+            result.append(server)
+    return result
+def parse_mcp_like_json(
+    data: dict[str, Any], default_enabled: bool = True
+) -> list[MCPServerConfig]:
     # First, try top-level keys
     top_level = _collect_top_level(data, default_enabled)
+    res: list[MCPServerConfig] = []
     if top_level:
-        return top_level
-    # Then, try nested structures heuristically
-    nested = _collect_nested(data, default_enabled)
-    if not nested:
-        log.debug("No MCP-like entries detected in provided data")
-    return nested
+        res = top_level
+    else:
+        # Then, try nested structures heuristically
+        nested = _collect_nested(data, default_enabled)
+        if not nested:
+            log.debug("No MCP-like entries detected in provided data")
+        res = nested
+    return deduplicate_by_name(res)

src/mcp_importer/quick_cli.py CHANGED Viewed

@@ -1,5 +1,3 @@
-from __future__ import annotations
 import argparse
 from collections.abc import Iterable

src/mcp_importer/types.py CHANGED Viewed

@@ -1,5 +1,3 @@
 """Type helpers for MCP importer."""
-from __future__ import annotations
 # This module intentionally minimal to avoid unused code flags.

open-edison 0.1.44__py3-none-any.whl → 0.1.72rc1__py3-none-any.whl

open-edison 0.1.44py3-none-any.whl → 0.1.72rc1py3-none-any.whl