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

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/main.py

@@ -1,15 +1,26 @@
 import argparse
+import asyncio
+import contextlib
+import sys
+from collections.abc import Generator
 
 import questionary
+from loguru import logger as log
 
-from src.config import MCPServerConfig
+import src.oauth_manager as oauth_mod
+from src.config import MCPServerConfig, get_config_dir
 from src.mcp_importer.api import (
     CLIENT,
+    authorize_server_oauth,
     detect_clients,
     export_edison_to,
+    has_oauth_tokens,
     import_from,
+    save_imported_servers,
     verify_mcp_server,
 )
+from src.mcp_importer.parsers import deduplicate_by_name
+from src.oauth_manager import OAuthStatus, get_oauth_manager
 
 
 def show_welcome_screen(*, dry_run: bool = False) -> None:
@@ -31,7 +42,9 @@ def show_welcome_screen(*, dry_run: bool = False) -> None:
     questionary.confirm("Ready to begin the setup process?", default=True).ask()
 
 
-def handle_mcp_source(source: CLIENT, *, dry_run: bool = False) -> list[MCPServerConfig]:
+def handle_mcp_source(  # noqa: C901
+    source: CLIENT, *, dry_run: bool = False, skip_oauth: bool = False
+) -> list[MCPServerConfig]:
     """Handle the MCP source."""
     if not questionary.confirm(
         f"We have found {source.name} installed. Would you like to import its MCP servers to open-edison?",
@@ -41,18 +54,65 @@ def handle_mcp_source(source: CLIENT, *, dry_run: bool = False) -> list[MCPServe
 
     configs = import_from(source)
 
+    # Filter out any "open-edison" configs
+    if "open-edison" in [config.name for config in configs]:
+        print(
+            "Found an 'open-edison' config. This is not allowed, so it will be excluded from the import."
+        )
+
+    configs = [config for config in configs if config.name != "open-edison"]
+
     print(f"Loaded {len(configs)} MCP server configuration from {source.name}!")
 
     verified_configs: list[MCPServerConfig] = []
 
     for config in configs:
-        print(f"Verifying the configuration for {config.name}... (TODO)")
+        print(f"Verifying the configuration for {config.name}... ")
         result = verify_mcp_server(config)
         if result:
+            # For remote servers, only prompt if OAuth is actually required
+            if config.is_remote_server():
+                # Heuristic: if inline headers are present (e.g., API key), treat as not requiring OAuth
+                has_inline_headers: bool = any(
+                    (a == "--header" or a.startswith("--header")) for a in config.args
+                )
+                if not has_inline_headers:
+                    # Prefer cached result from verification; only check if missing
+                    oauth_mgr = get_oauth_manager()
+                    info = oauth_mgr.get_server_info(config.name)
+                    if info is None:
+                        info = asyncio.run(
+                            oauth_mgr.check_oauth_requirement(config.name, config.get_remote_url())
+                        )
+
+                    if info.status == OAuthStatus.NEEDS_AUTH:
+                        tokens_present: bool = has_oauth_tokens(config)
+                        if not tokens_present:
+                            if skip_oauth:
+                                print(
+                                    f"Skipping OAuth for {config.name} due to --skip-oauth (OAuth required, no tokens). This server will not be imported."
+                                )
+                                continue
+
+                            if questionary.confirm(
+                                f"{config.name} requires OAuth and no credentials were found. Obtain credentials now?",
+                                default=True,
+                            ).ask():
+                                success = authorize_server_oauth(config)
+                                if not success:
+                                    print(
+                                        f"Failed to obtain OAuth credentials for {config.name}. Skipping this server."
+                                    )
+                                    continue
+                            else:
+                                print(f"Skipping {config.name} per user choice.")
+                                continue
+
+            print(f"Verification successful for {config.name}.")
             verified_configs.append(config)
         else:
             print(
-                f"The configuration for {config.name} is not valid. Please check the configuration and try again."
+                f"Verification failed for the configuration of {config.name}. Please check the configuration and try again."
             )
 
     return verified_configs
@@ -95,8 +155,10 @@ def show_manual_setup_screen() -> None:
 
     To set up open-edison manually in other clients, find your client's MCP config
     JSON file and add the following configuration:
+    """
 
-    "mcpServers": {
+    json_snippet = """\t{
+      "mcpServers": {
         "open-edison": {
           "command": "npx",
           "args": [
@@ -108,48 +170,123 @@ def show_manual_setup_screen() -> None:
             "Authorization: Bearer dev-api-key-change-me"
           ]
         }
-      },
+      }
+    }"""
 
+    after_text = """
     Make sure to replace 'dev-api-key-change-me' with your actual API key.
     """
 
     print(manual_setup_text)
+    # Use questionary's print with style for color
+    questionary.print(json_snippet, style="bold fg:ansigreen")
+    print(after_text)
+
+
+class _TuiLogger:
+    def _fmt(self, msg: object, *args: object) -> str:
+        try:
+            if isinstance(msg, str) and args:
+                return msg.format(*args)
+        except Exception:
+            pass
+        return str(msg)
+
+    def info(self, msg: object, *args: object, **kwargs: object) -> None:
+        questionary.print(self._fmt(msg, *args), style="fg:ansiblue")
+
+    def debug(self, msg: object, *args: object, **kwargs: object) -> None:
+        questionary.print(self._fmt(msg, *args), style="fg:ansiblack")
+
+    def warning(self, msg: object, *args: object, **kwargs: object) -> None:
+        questionary.print(self._fmt(msg, *args), style="bold fg:ansiyellow")
+
+    def error(self, msg: object, *args: object, **kwargs: object) -> None:
+        questionary.print(self._fmt(msg, *args), style="bold fg:ansired")
+
+
+@contextlib.contextmanager
+def suppress_loguru_output() -> Generator[None, None, None]:
+    """Suppress loguru output."""
+    with contextlib.suppress(Exception):
+        log.remove()
+
+    old_logger = oauth_mod.log
+    # Route oauth_manager's log calls to questionary for TUI output
+    oauth_mod.log = _TuiLogger()  # type: ignore[attr-defined]
+    yield
+    oauth_mod.log = old_logger
+    log.add(sys.stdout, level="INFO")
 
 
-def run(*, dry_run: bool = False) -> None:
-    """Run the complete setup process."""
+@suppress_loguru_output()
+def run(*, dry_run: bool = False, skip_oauth: bool = False) -> bool:  # noqa: C901
+    """Run the complete setup process.
+    Returns whether the setup was successful."""
     show_welcome_screen(dry_run=dry_run)
     # Additional setup steps will be added here
 
-    mcp_sources = detect_clients()
-    mcp_clients = detect_clients()
+    mcp_clients = sorted(detect_clients(), key=lambda x: x.value)
 
     configs: list[MCPServerConfig] = []
 
-    for source in mcp_sources:
-        configs.extend(handle_mcp_source(source, dry_run=dry_run))
+    for client in mcp_clients:
+        configs.extend(handle_mcp_source(client, dry_run=dry_run, skip_oauth=skip_oauth))
 
     if len(configs) == 0:
-        print(
-            "No MCP servers found. Please set up an MCP client with some servers and run this setup again."
-        )
-        return
+        if not questionary.confirm(
+            "No MCP servers found. Would you like to continue without them?", default=False
+        ).ask():
+            print("Setup aborted. Please configure an MCP client and try again.")
+            return False
+        return True
+
+    # Deduplicate configs
+    configs = deduplicate_by_name(configs)
 
     if not confirm_configs(configs, dry_run=dry_run):
-        return
+        return False
 
     for client in mcp_clients:
         confirm_apply_configs(client, dry_run=dry_run)
 
+    # Persist imported servers into config.json
+    if len(configs) > 0:
+        save_imported_servers(configs, dry_run=dry_run)
+
     show_manual_setup_screen()
 
+    return True
+
+
+# Triggered from cli.py
+def run_import_tui(args: argparse.Namespace, force: bool = False) -> bool:
+    """Run the import TUI, if necessary."""
+    # Find config dir, check if ".setup_tui_ran" exists
+    config_dir = get_config_dir()
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    setup_tui_ran_file = config_dir / ".setup_tui_ran"
+    success = True
+    if not setup_tui_ran_file.exists() or force:
+        success = run(dry_run=args.wizard_dry_run, skip_oauth=args.wizard_skip_oauth)
+
+    setup_tui_ran_file.touch()
+
+    return success
+
 
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description="Open Edison Setup TUI")
     parser.add_argument("--dry-run", action="store_true", help="Preview actions without writing")
+    parser.add_argument(
+        "--skip-oauth",
+        action="store_true",
+        help="Skip OAuth for remote servers (they will be omitted from import)",
+    )
     args = parser.parse_args(argv)
 
-    run(dry_run=args.dry_run)
+    run(dry_run=args.dry_run, skip_oauth=args.skip_oauth)
     return 0
 
 

src/single_user_mcp.py

@@ -9,6 +9,7 @@ from typing import Any, TypedDict
 
 from fastmcp import Client as FastMCPClient
 from fastmcp import Context, FastMCP
+from fastmcp.server.dependencies import get_context
 from loguru import logger as log
 
 from src.config import Config, MCPServerConfig
@@ -281,9 +282,6 @@ class SingleUserMCP(FastMCP[Any]):
     async def _send_list_changed_notifications(self) -> None:
         """Send notifications to clients about changed component lists."""
         try:
-            # Import here to avoid circular imports
-            from fastmcp.server.dependencies import get_context
-
             try:
                 context = get_context()
                 # Queue notifications for all component types since we don't know
@@ -323,12 +321,18 @@ class SingleUserMCP(FastMCP[Any]):
         log.info("✅ Single User MCP server initialized with composite proxy")
 
         # Invalidate and warm lists to ensure reload
+        log.debug("Reloading tool list...")
         _ = await self._tool_manager.list_tools()
+        log.debug("Reloading resource list...")
         _ = await self._resource_manager.list_resources()
+        log.debug("Reloading prompt list...")
         _ = await self._prompt_manager.list_prompts()
+        log.debug("Reloading complete")
 
         # Send notifications to clients about changed component lists
+        log.debug("Sending list changed notifications...")
         await self._send_list_changed_notifications()
+        log.debug("List changed notifications sent")
 
     def _calculate_risk_level(self, trifecta: dict[str, bool]) -> str:
         """

src/tools/io.py

@@ -0,0 +1,35 @@
+import os
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+
+@contextmanager
+def suppress_fds(*, suppress_stdout: bool = False, suppress_stderr: bool = True) -> Iterator[None]:
+    """Temporarily redirect process-level stdout/stderr to os.devnull.
+
+    Args:
+        suppress_stdout: If True, redirect fd 1 to devnull
+        suppress_stderr: If True, redirect fd 2 to devnull
+
+    Yields:
+        None
+    """
+    saved: list[tuple[int, int]] = []
+    try:
+        if suppress_stdout:
+            saved.append((1, os.dup(1)))
+            devnull_out = os.open(os.devnull, os.O_WRONLY)
+            os.dup2(devnull_out, 1)
+            os.close(devnull_out)
+        if suppress_stderr:
+            saved.append((2, os.dup(2)))
+            devnull_err = os.open(os.devnull, os.O_WRONLY)
+            os.dup2(devnull_err, 2)
+            os.close(devnull_err)
+        yield
+    finally:
+        for fd, backup in saved:
+            try:
+                os.dup2(backup, fd)
+            finally:
+                os.close(backup)

src/vulture_whitelist.py

@@ -0,0 +1,3 @@
+from src.oauth_override import OpenEdisonOAuth
+
+OpenEdisonOAuth.redirect_handler  # noqa: B018 unused method (src/oauth_override.py:7)

open_edison-0.1.44.dist-info/RECORD

@@ -1,37 +0,0 @@
-src/__init__.py,sha256=bEYMwBiuW9jzF07iWhas4Vb30EcpnqfpNfz_Q6yO1jU,209
-src/__main__.py,sha256=kQsaVyzRa_ESC57JpKDSQJAHExuXme0rM5beJsYxFeA,161
-src/cli.py,sha256=fqX-HuRDePRasexpnURQ_pVYeycJuWxllMcwfqDxMQw,8490
-src/config.py,sha256=RSsAYzl8cj6eaDN1RORMcfKKWBcp4bKTQp2BdhAL9mg,10258
-src/config.pyi,sha256=FgehEGli8ZXSjGlANBgMGv5497q4XskQciOc1fUcxqM,2033
-src/events.py,sha256=aFQrVXDIZwt55Dz6OtyoXu2yi9evqo-8jZzo3CR2Tto,4965
-src/oauth_manager.py,sha256=W9QSo0vfGDQ_i-QWCngkv7YLSL3Rk5jfPmqjU1J2rnU,9911
-src/permissions.py,sha256=NGAnlG_z59HEiVA-k3cYvwmmiuHzxuNb5Tbd5umbL00,10483
-src/server.py,sha256=cnO5bgxT-lrfuwk9AIvB_HBV8SWOtFClfGUn5_zFWyo,45652
-src/single_user_mcp.py,sha256=rJrlqHcIubGkos_24ux5rb3OoKYDzvagCHghhfDeXTI,18535
-src/telemetry.py,sha256=-RZPIjpI53zbsKmp-63REeZ1JirWHV5WvpSRa2nqZEk,11321
-src/frontend_dist/index.html,sha256=s95FMkH8VLisvawLH7bZxbLzRUFvMhHkH6ZMzpVBngs,673
-src/frontend_dist/sw.js,sha256=rihX1es-vWwjmtnXyaksJjs2dio6MVAOTAWwQPeJUYw,2164
-src/frontend_dist/assets/index-BUUcUfTt.js,sha256=awoyPI6u0v6ao2iarZdSkrSDUvyU8aNkMLqHMvgVgyY,257666
-src/frontend_dist/assets/index-o6_8mdM8.css,sha256=nwmX_6q55mB9463XN2JM8BdeihjkALpQK83Fc3_iGvE,15936
-src/mcp_importer/__init__.py,sha256=Mk59pVr7OMGfYGWeSYk8-URfhIcrs3SPLYS7fmJbMII,275
-src/mcp_importer/__main__.py,sha256=0jVfxKzyr6koVu1ghhWseah5ilKIoGovE6zkEZ-u-Og,515
-src/mcp_importer/api.py,sha256=47tur0xgl1NBI1Vnh3cpScEmDS64bKMYcWjZDuqx7HQ,6644
-src/mcp_importer/cli.py,sha256=Pe0GLWm1nMd1VuNXOSkxIrFZuGNFc9dNvfBsvf-bdBI,3487
-src/mcp_importer/export_cli.py,sha256=daEadB6nL8P4OpEGFx0GshuN1a091L7BhiitpV1bPqA,6294
-src/mcp_importer/exporters.py,sha256=fSgl6seduoXFp7YnKH26UEaC1sFBnd4whSut7CJLBQs,11348
-src/mcp_importer/import_api.py,sha256=xWaKoE3vibSWpA5roVL7qEMS73vcmAC0tcHP6CsZw6E,95
-src/mcp_importer/importers.py,sha256=zGN8lT7qQJ95jDTd-ck09j_w5PSvH-uj33TILoHfHbs,2191
-src/mcp_importer/merge.py,sha256=KIGT7UgbAm07-LdyoUXEJ7ABSIiPTFlj_qjz669yFxg,1569
-src/mcp_importer/parsers.py,sha256=JRE7y_Gg-QmlAARvZdrI9CmUyy-ODvDPbS695pb3Aw8,4856
-src/mcp_importer/paths.py,sha256=4L-cPr7KCM9X9gAUP7Da6ictLNrPWuQ_IM419zqY-2I,2700
-src/mcp_importer/quick_cli.py,sha256=4mJe10q_lZCYLm75QBt1rYy2j8mGEsRZoAqA0agjfSM,1834
-src/mcp_importer/types.py,sha256=h03TbAnJbap6OWWd0dT0QcFWNvSaiVFWH9V9PD6x4s0,138
-src/middleware/data_access_tracker.py,sha256=bArBffWgYmvxOx9z_pgXQhogvnWQcc1m6WvEblDD4gw,15039
-src/middleware/session_tracking.py,sha256=5W1VH9HNqIZeX0HNxDEm41U4GY6SqKSXtApDEeZK2qo,23084
-src/setup_tui/__init__.py,sha256=mDFrQoiOtQOHc0sFfGKrNXVLEDeB1S0O5aISBVzfxYo,184
-src/setup_tui/main.py,sha256=892X2KVKOYmKzUu1Ok8SnApNYxpcFHFHmFLvpPZP4qY,5501
-open_edison-0.1.44.dist-info/METADATA,sha256=hY2fd8IeT-YeBAUjg_FBtpGf50VGOpgRp4xdBhx7ED4,12375
-open_edison-0.1.44.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_edison-0.1.44.dist-info/entry_points.txt,sha256=YiGNm9x2I00hgT10HDyB4gxC1LcaV_mu8bXFjolu0Yw,171
-open_edison-0.1.44.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-open_edison-0.1.44.dist-info/RECORD,,