open-edison 0.1.43__py3-none-any.whl → 0.1.64__py3-none-any.whl

src/mcp_importer/api.py

@@ -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

@@ -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/import_api.py

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

src/mcp_importer/parsers.py

@@ -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

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

src/mcp_importer/types.py

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

src/oauth_manager.py

@@ -19,6 +19,8 @@ from fastmcp.client.auth.oauth import (
 )
 from loguru import logger as log
 
+from src.oauth_override import OpenEdisonOAuth
+
 
 class OAuthStatus(Enum):
     """OAuth authentication status for MCP servers."""
@@ -209,7 +211,7 @@ class OAuthManager:
             return None
 
         try:
-            oauth = OAuth(
+            oauth = OpenEdisonOAuth(
                 mcp_url=mcp_url,
                 scopes=scopes or info.scopes,
                 client_name=client_name or info.client_name,

src/oauth_override.py

@@ -0,0 +1,10 @@
+import webbrowser
+
+from fastmcp.client.auth.oauth import OAuth as _FastMCPOAuth
+
+
+class OpenEdisonOAuth(_FastMCPOAuth):
+    async def redirect_handler(self, authorization_url: str) -> None:  # noqa: ARG002
+        # Print a clean, single-line URL and still open the browser.
+        print(f"OAuth authorization URL: {authorization_url}", flush=True)
+        webbrowser.open(authorization_url)

src/permissions.py

@@ -7,6 +7,7 @@ Reads tool, resource, and prompt permission files and provides a singleton inter
 
 import json
 from dataclasses import dataclass
+from functools import cache
 from pathlib import Path
 from typing import Any
 
@@ -158,6 +159,12 @@ class Permissions:
             )
 
     @classmethod
+    def clear_permissions_file_cache(cls) -> None:
+        """Clear the cache for the JSON permissions files"""
+        cls._load_permission_file.cache_clear()
+
+    @classmethod
+    @cache
     def _load_permission_file(
         cls,
         file_path: Path,
@@ -171,7 +178,23 @@ class Permissions:
         metadata: PermissionsMetadata | None = None
 
         if not file_path.exists():
-            raise PermissionsError(f"Permissions file not found at {file_path}")
+            # Bootstrap missing permissions files on first run.
+            # Prefer copying repo/package defaults (next to src/), else create minimal stub.
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+
+            repo_candidate = Path(__file__).parent.parent / file_path.name
+            if repo_candidate.exists():
+                file_path.write_text(repo_candidate.read_text(encoding="utf-8"), encoding="utf-8")
+                log.info(f"Bootstrapped permissions file from defaults: {file_path}")
+            if not file_path.exists():
+                # Create minimal empty structure
+                try:
+                    file_path.write_text(json.dumps({"_metadata": {}}), encoding="utf-8")
+                    log.info(f"Created empty permissions file: {file_path}")
+                except Exception as e:
+                    raise PermissionsError(
+                        f"Unable to create permissions file at {file_path}: {e}", file_path
+                    ) from e
 
         with open(file_path) as f:
             data: dict[str, Any] = json.load(f)

src/server.py

@@ -1,12 +1,12 @@
 """
-Open Edison Server
-
-Simple FastAPI + FastMCP server for single-user MCP proxy.
-No multi-user support, no complex routing - just a straightforward proxy.
+Open Edison MCP Proxy Server
+Main server entrypoint for FastAPI and FastMCP integration.
+See README for usage and configuration details.
 """
 
 import asyncio
 import json
+import signal
 import traceback
 from collections.abc import Awaitable, Callable, Coroutine
 from contextlib import suppress
@@ -25,6 +25,7 @@ from fastapi.responses import (
 )
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
 from fastapi.staticfiles import StaticFiles
+from fastmcp import Client as FastMCPClient
 from fastmcp import FastMCP
 from loguru import logger as log
 from pydantic import BaseModel, Field
@@ -37,6 +38,8 @@ from src.middleware.session_tracking import (
     create_db_session,
 )
 from src.oauth_manager import OAuthStatus, get_oauth_manager
+from src.oauth_override import OpenEdisonOAuth
+from src.permissions import Permissions
 from src.single_user_mcp import SingleUserMCP
 from src.telemetry import initialize_telemetry, set_servers_installed
 
@@ -276,6 +279,12 @@ class OpenEdisonProxy:
                 # Clear cache for the config file, if it was config.json
                 if name == "config.json":
                     clear_json_file_cache()
+                elif name in (
+                    "tool_permissions.json",
+                    "resource_permissions.json",
+                    "prompt_permissions.json",
+                ):
+                    Permissions.clear_permissions_file_cache()
 
                 return {"status": "ok"}
             except Exception as e:  # noqa: BLE001
@@ -397,6 +406,7 @@ class OpenEdisonProxy:
             host=self.host,
             port=self.port + 1,
             log_level=Config().logging.level.lower(),
+            timeout_graceful_shutdown=0,
         )
         fastapi_server = uvicorn.Server(fastapi_config)
         servers_to_run.append(fastapi_server.serve())
@@ -408,13 +418,27 @@ class OpenEdisonProxy:
             host=self.host,
             port=self.port,
             log_level=Config().logging.level.lower(),
+            timeout_graceful_shutdown=0,
         )
         fastmcp_server = uvicorn.Server(fastmcp_config)
         servers_to_run.append(fastmcp_server.serve())
 
         # Run both servers concurrently
         log.info("🚀 Starting both FastAPI and FastMCP servers...")
-        _ = await asyncio.gather(*servers_to_run)
+        loop = asyncio.get_running_loop()
+
+        def _trigger_shutdown(signame: str) -> None:
+            log.info(f"Received {signame}. Forcing shutdown of all servers...")
+            for srv in (fastapi_server, fastmcp_server):
+                with suppress(Exception):
+                    srv.force_exit = True  # type: ignore[attr-defined] # noqa
+                    srv.should_exit = True  # type: ignore[attr-defined] # noqa
+
+        for sig in (signal.SIGINT, signal.SIGTERM):
+            with suppress(Exception):
+                loop.add_signal_handler(sig, _trigger_shutdown, sig.name)
+
+        await asyncio.gather(*servers_to_run, return_exceptions=False)
 
     def _register_routes(self, app: FastAPI) -> None:
         """Register all routes for the FastAPI app"""
@@ -953,12 +977,8 @@ class OpenEdisonProxy:
 
             log.info(f"🔗 Testing connection to {server_name} at {remote_url}")
 
-            # Import FastMCP client for testing
-            from fastmcp import Client as FastMCPClient
-            from fastmcp.client.auth import OAuth
-
             # Create OAuth auth object
-            oauth = OAuth(
+            oauth = OpenEdisonOAuth(
                 mcp_url=remote_url,
                 scopes=scopes,
                 client_name=client_name or "OpenEdison MCP Gateway",

src/setup_tui/__init__.py

@@ -0,0 +1,5 @@
+"""Setup TUI package initializer.
+
+Intentionally empty to avoid importing submodules at package import time,
+which prevents warnings when executing `python -m src.setup_tui.main`.
+"""