open-edison 0.1.80rc1__tar.gz → 0.1.84rc1__tar.gz

{open_edison-0.1.80rc1 → open_edison-0.1.84rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-edison
-Version: 0.1.80rc1
+Version: 0.1.84rc1
 Summary: Open-source MCP security, aggregation, and monitoring. Single-user, self-hosted MCP proxy.
 Author-email: Hugo Berg <hugo@edison.watch>
 License-File: LICENSE
@@ -16,6 +16,7 @@ Requires-Dist: opentelemetry-api>=1.36.0
 Requires-Dist: opentelemetry-exporter-otlp>=1.36.0
 Requires-Dist: opentelemetry-sdk>=1.36.0
 Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: python-rapidjson>=1.21
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: questionary>=2.1.1
 Requires-Dist: sqlalchemy>=2.0.41

{open_edison-0.1.80rc1 → open_edison-0.1.84rc1}/config.json

@@ -17,7 +17,8 @@
             "args": [
                 "-y",
                 "@modelcontextprotocol/server-filesystem",
-                "/tmp"
+                "/tmp",
+                "/private/tmp"
             ],
             "env": {},
             "enabled": true,
@@ -25,13 +26,12 @@
         },
         {
             "name": "fetch",
-            "command": "npx",
+            "command": "uvx",
             "args": [
-                "-y",
-                "@modelcontextprotocol/server-everything"
+                "mcp-server-fetch"
             ],
             "env": {},
-            "enabled": false
+            "enabled": true
         },
         {
             "name": "github",

{open_edison-0.1.80rc1 → open_edison-0.1.84rc1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "open-edison"
-version = "0.1.80rc1"
+version = "0.1.84rc1"
 description = "Open-source MCP security, aggregation, and monitoring. Single-user, self-hosted MCP proxy."
 readme = "README.md"
 authors = [
@@ -23,8 +23,9 @@ dependencies = [
     "opentelemetry-exporter-otlp>=1.36.0",
     "hatchling>=1.27.0",
     "questionary>=2.1.1",
+    "python-rapidjson>=1.21",
 ]
-requires-python = ">= 3.12"
+requires-python = ">=3.12"
 
 [project.scripts]
 open-edison = "src.cli:main"

{open_edison-0.1.80rc1 → open_edison-0.1.84rc1}/src/cli.py

@@ -6,18 +6,18 @@ Provides the `open-edison` executable when installed via pip/uvx/pipx.
 import argparse
 import asyncio
 import os
+import sys
 from pathlib import Path
 from typing import Any, NoReturn
 
-from loguru import logger as _log  # type: ignore[reportMissingImports]
+from loguru import logger as log
 
 from src.config import Config, get_config_dir, get_config_json_path
+from src.demos.trifecta import demo_config_dir, run_trifecta_demo
 from src.mcp_importer.cli import run_cli
 from src.server import OpenEdisonProxy
 from src.setup_tui.main import run_import_tui
 
-log: Any = _log
-
 
 def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
     parser: Any = argparse.ArgumentParser(
@@ -98,6 +98,13 @@ def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
         action="store_true",
         help="Show changes without writing to config.json",
     )
+    _ = subparsers.add_parser(
+        "demo-trifecta",
+        help="Run the Simple Trifecta Demo setup and print the prompt",
+        description=(
+            "Seeds a demo secret file in /tmp, checks config hints, and prints the demo prompt."
+        ),
+    )
 
     return parser.parse_args(argv)
 
@@ -132,8 +139,24 @@ def main(argv: list[str] | None = None) -> NoReturn:  # noqa: C901
         args.command = "run"
 
     if args.command == "import-mcp":
-        result_code = run_cli(argv)
+        # Forward only the subcommand args (exclude the 'import-mcp' token itself)
+        if argv is None:
+            argv = sys.argv[1:]
+        raw_args = list(argv)
+        try:
+            subcmd_index = raw_args.index("import-mcp")
+            sub_argv = raw_args[subcmd_index + 1 :]
+        except ValueError:
+            sub_argv = raw_args
+
+        result_code = run_cli(sub_argv)
         raise SystemExit(result_code)
+    if args.command == "demo-trifecta":
+        run_trifecta_demo()
+        with demo_config_dir() as demo_dir:
+            os.environ["OPEN_EDISON_CONFIG_DIR"] = str(demo_dir)
+            asyncio.run(_run_server(args))
+        raise SystemExit(0)
 
     # Run import tui if necessary
     tui_success = run_import_tui(args, force=args.wizard_force)

{open_edison-0.1.80rc1 → open_edison-0.1.84rc1}/src/config.py

@@ -63,6 +63,63 @@ def get_config_json_path() -> Path:
     return get_config_dir() / "config.json"
 
 
+def repo_defaults_path(filename: str) -> Path:
+    """Path to repository/package-default JSON next to src/.
+
+    Example: repo_defaults_path("tool_permissions.json") -> /.../src/../tool_permissions.json
+    """
+    return root_dir / filename
+
+
+def ensure_permissions_file(file_path: Path, *, default_json: dict[str, Any] | None = None) -> Path:
+    """Ensure a permissions JSON file exists at file_path.
+
+    Behavior:
+    - If file exists: return it
+    - Else: try to copy repo default (next to src/) into place; if not present, write minimal stub
+    - Returns the final path (which should exist unless write failed)
+    """
+    if file_path.exists():
+        return file_path
+
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+
+    repo_candidate = repo_defaults_path(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}")
+        return file_path
+
+    # Minimal stub when no repo default available
+    minimal_obj: dict[str, Any] = default_json if default_json is not None else {"_metadata": {}}
+    file_path.write_text(json.dumps(minimal_obj, indent=2), encoding="utf-8")
+    log.info(f"Created minimal permissions file: {file_path}")
+    return file_path
+
+
+def resolve_json_path_with_bootstrap(filename: str) -> Path:
+    """Resolve a JSON config file path with repo bootstrap fallback.
+
+    Precedence:
+    1) Return config-dir path if it already exists
+    2) If repo default exists, attempt to copy it into config-dir and return the copied path
+    3) Return the config-dir target path (may not exist yet)
+    """
+    base = get_config_dir()
+    target = base / filename
+    if target.exists():
+        return target
+
+    repo_candidate = repo_defaults_path(filename)
+    if repo_candidate.exists():
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(repo_candidate.read_text(encoding="utf-8"), encoding="utf-8")
+        return target
+    raise FileNotFoundError(
+        f"File {filename} not found in the src repo and could not be bootstrapped"
+    )
+
+
 @dataclass
 class ServerConfig:
     """Server configuration"""

{open_edison-0.1.80rc1 → open_edison-0.1.84rc1}/src/config.pyi

@@ -7,6 +7,11 @@ root_dir: Path
 
 def get_config_dir() -> Path: ...
 def get_config_json_path() -> Path: ...
+def repo_defaults_path(filename: str) -> Path: ...
+def ensure_permissions_file(
+    file_path: Path, *, default_json: dict[str, Any] | None = None
+) -> Path: ...
+def resolve_json_path_with_bootstrap(filename: str) -> Path: ...
 
 class ServerConfig:
     host: str

open_edison-0.1.84rc1/src/demos/trifecta.py

@@ -0,0 +1,110 @@
+"""
+Trifecta demo runner used by the CLI and the standalone script.
+
+This module seeds a secret file under the tmp directory, checks for basic
+config hints, and prints the user prompt found at demo/trifecta_user_prompt.txt.
+
+Additionally, it provides a helper to create a temporary configuration
+directory containing `config.json` and the three permissions JSON files
+so the demo can run with a known-good configuration without touching the
+user's real config directory.
+"""
+
+import sys
+from collections.abc import Generator
+from contextlib import contextmanager
+from datetime import UTC, datetime
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+import questionary
+from loguru import logger as log
+
+
+def _get_tmp_root() -> Path:
+    if sys.platform == "darwin":
+        return Path("/private/tmp")
+    return Path("/tmp")
+
+
+TMP_ROOT = _get_tmp_root()
+SECRET_DIR = TMP_ROOT / "open-edison"
+SECRET_FILE = SECRET_DIR / "mysecretdetails.txt"
+
+
+def _load_project_version(pyproject_path: Path) -> str:
+    try:
+        import tomllib
+
+        with pyproject_path.open("rb") as f:
+            data = tomllib.load(f)
+        project = data.get("project", {})
+        return str(project.get("version", "unknown"))
+    except Exception:
+        return "unknown"
+
+
+def _seed_secret_file(version: str) -> None:
+    SECRET_DIR.mkdir(parents=True, exist_ok=True)
+    installed_ts = datetime.now(UTC).isoformat()
+    lines = [
+        "Open Edison Demo Secret",
+        f"version={version}",
+        f"installed_utc={installed_ts}",
+    ]
+    SECRET_FILE.write_text("\n".join(lines), encoding="utf-8")
+
+
+@contextmanager
+def demo_config_dir() -> Generator[Path, None, None]:
+    """Create a temporary config directory for the demo with JSONs.
+
+    Copies `config.json`, `tool_permissions.json`, `resource_permissions.json`,
+    and `prompt_permissions.json` from the repository root into a new directory
+    under the system tmp path. Ensures the `fetch` and `filesystem` servers are
+    enabled in the copied `config.json`. Returns the created directory path.
+    """
+    repo_root = Path(__file__).resolve().parents[2]
+    filenames = [
+        "config.json",
+        "tool_permissions.json",
+        "resource_permissions.json",
+        "prompt_permissions.json",
+    ]
+
+    with TemporaryDirectory(prefix="open-edison-demo-") as tmp_dir:
+        demo_dir = Path(tmp_dir)
+        for filename in filenames:
+            log.debug(f"Copying {filename} to {demo_dir / filename}")
+            (demo_dir / filename).write_text(
+                (repo_root / filename).read_text(encoding="utf-8"), encoding="utf-8"
+            )
+
+        log.info(f"Created temporary demo config directory: {demo_dir}")
+        yield demo_dir
+
+
+def run_trifecta_demo() -> None:
+    repo_root = Path(__file__).resolve().parents[2]
+    pyproject = repo_root / "pyproject.toml"
+    version = _load_project_version(pyproject)
+
+    _seed_secret_file(version)
+
+    print("\n=== Open Edison: Simple Trifecta Demo Setup ===")
+    print(f"Seeded secret file at: {SECRET_FILE}")
+    print(f"Project version detected: {version}")
+
+    print("\nNext step: Copy/paste this prompt into your MCP client:")
+    print("----------------------------------------------------")
+    prompt_path = repo_root / "demo" / "trifecta_user_prompt.txt"
+    prompt_text = prompt_path.read_text(encoding="utf-8").strip()
+    print(prompt_text)
+    print("----------------------------------------------------")
+
+    questionary.confirm(
+        "Have you copied the prompt into your MCP client and are ready to launch the server now?",
+        default=True,
+    ).ask()
+
+    # On return, the cli.py handles launching the server

{open_edison-0.1.80rc1 → open_edison-0.1.84rc1}/src/mcp_importer/importers.py

@@ -5,7 +5,7 @@ from loguru import logger as log
 
 from src.config import MCPServerConfig
 
-from .parsers import ImportErrorDetails, parse_mcp_like_json, safe_read_json
+from .parsers import ImportErrorDetails, parse_mcp_like_json, permissive_read_json
 from .paths import (
     find_claude_code_user_all_candidates,
     find_claude_code_user_settings_file,
@@ -22,17 +22,29 @@ def import_from_cursor() -> list[MCPServerConfig]:
             "Cursor MCP config not found (~/.cursor/mcp.json).",
             Path.home() / ".cursor" / "mcp.json",
         )
-    data = safe_read_json(files[0])
+    data = permissive_read_json(files[0])
     return parse_mcp_like_json(data, default_enabled=True)
 
 
 def import_from_vscode() -> list[MCPServerConfig]:
     files = find_vscode_user_mcp_file()
     if not files:
-        raise ImportErrorDetails("VSCode mcp.json not found at User/mcp.json on macOS/Linux.")
-    log.info("VSCode MCP config detected at: {}", files[0])
-    data = safe_read_json(files[0])
-    return parse_mcp_like_json(data, default_enabled=True)
+        raise ImportErrorDetails(
+            "VSCode configuration not found (checked User/mcp.json and User/settings.json)."
+        )
+    # Try each file; stop at the first that yields MCP servers
+    for f in files:
+        try:
+            log.info("VSCode config detected at: {}", f)
+            data = permissive_read_json(f)
+            parsed = parse_mcp_like_json(data, default_enabled=True)
+            if parsed:
+                return parsed
+        except Exception as e:
+            print(f"Failed reading VSCode config {f}: {e}")
+    # If we saw files but none yielded servers, return empty with info
+    log.info("No MCP servers found in VSCode config candidates; returning empty list")
+    return []
 
 
 def import_from_claude_code() -> list[MCPServerConfig]:
@@ -44,7 +56,7 @@ def import_from_claude_code() -> list[MCPServerConfig]:
     for f in files:
         try:
             log.info("Claude Code config detected at: {}", f)
-            data = safe_read_json(f)
+            data = permissive_read_json(f)
             parsed = parse_mcp_like_json(data, default_enabled=True)
             if parsed:
                 return parsed

{open_edison-0.1.80rc1 → open_edison-0.1.84rc1}/src/mcp_importer/parsers.py

@@ -1,10 +1,8 @@
-# pyright: reportUnknownArgumentType=false, reportUnknownVariableType=false, reportMissingImports=false, reportUnknownMemberType=false
-
-import json
 import shlex
 from pathlib import Path
 from typing import Any, cast
 
+import rapidjson
 from loguru import logger as log
 
 from src.config import MCPServerConfig
@@ -38,10 +36,13 @@ class ImportErrorDetails(Exception):  # noqa: N818
         self.path = path
 
 
-def safe_read_json(path: Path) -> dict[str, Any]:
+# Many clients, like vscode, allow comments and trailing commas etc in their settings files.
+def permissive_read_json(path: Path) -> dict[str, Any]:
     try:
         with open(path, encoding="utf-8") as f:
-            loaded = json.load(f)
+            loaded = rapidjson.load(
+                f, parse_mode=rapidjson.PM_COMMENTS | rapidjson.PM_TRAILING_COMMAS
+            )
     except Exception as e:
         raise ImportErrorDetails(f"Failed to read JSON from {path}: {e}", path) from e
 

{open_edison-0.1.80rc1 → open_edison-0.1.84rc1}/src/mcp_importer/paths.py

@@ -17,14 +17,33 @@ def find_cursor_user_file() -> list[Path]:
     return [p] if p.exists() else []
 
 
+def _vscode_base_dirs() -> list[Path]:
+    """Return likely VSCode user base directories for different distributions."""
+    home = Path.home()
+    vscode_config_base = (
+        home / "Library" / "Application Support" if is_macos() else home / ".config"
+    )
+    return [
+        x
+        for x in [
+            vscode_config_base / "Code",
+            vscode_config_base / "Code - Insiders",
+            vscode_config_base / "VSCodium",
+            vscode_config_base / "Code - OSS",
+        ]
+        if x.exists()
+    ]
+
+
 def find_vscode_user_mcp_file() -> list[Path]:
-    """Find VSCode user-level MCP config (User/mcp.json) on macOS or Linux."""
-    if is_macos():
-        p = Path.home() / "Library" / "Application Support" / "Code" / "User" / "mcp.json"
-    else:
-        p = Path.home() / ".config" / "Code" / "User" / "mcp.json"
-    p = p.resolve()
-    return [p] if p.exists() else []
+    """Find VSCode user-level MCP config: prefer User/mcp.json; fall back to User/settings.json."""
+    results: list[Path] = []
+    for base in _vscode_base_dirs():
+        for filename in ("mcp.json", "settings.json"):
+            candidate = (base / "User" / filename).resolve()
+            if candidate.exists():
+                results.append(candidate)
+    return list(set(results))
 
 
 def find_claude_code_user_settings_file() -> list[Path]:
@@ -71,11 +90,11 @@ def detect_vscode_config_path() -> Path | None:
 
 
 def get_default_vscode_config_path() -> Path:
-    if is_macos():
-        return (
-            Path.home() / "Library" / "Application Support" / "Code" / "User" / "mcp.json"
-        ).resolve()
-    return (Path.home() / ".config" / "Code" / "User" / "mcp.json").resolve()
+    # Prefer the first base dir; target mcp.json under User/
+    existing_base_dir = next((base for base in _vscode_base_dirs() if base.exists()), None)
+    if existing_base_dir:
+        return (existing_base_dir / "User" / "mcp.json").resolve()
+    raise RuntimeError("No VSCode base directory found! Are you sure VSCode is installed?")
 
 
 def get_default_cursor_config_path() -> Path:

{open_edison-0.1.80rc1 → open_edison-0.1.84rc1}/src/middleware/session_tracking.py

@@ -16,7 +16,7 @@ from pathlib import Path
 from typing import Any, cast
 
 import mcp.types as mt
-from fastmcp.exceptions import ToolError
+from fastmcp.exceptions import NotFoundError, ToolError
 from fastmcp.prompts.prompt import FunctionPrompt
 from fastmcp.resources import FunctionResource
 from fastmcp.server.middleware import Middleware
@@ -277,6 +277,10 @@ class SessionTrackingMiddleware(Middleware):
             # Avoid noisy tracebacks for expected security blocks
             log.warning(f"MCP request blocked by security policy: {e}")
             raise
+        except NotFoundError as e:
+            # Tool/prompt/resource not found; avoid full traceback
+            log.warning(f"MCP tool/prompt/resource not found error: {e}")
+            raise
         except ToolError as e:
             # Upstream tool failed; avoid noisy traceback here. Specific handlers may format a response.
             log.warning(f"MCP tool error: {e}")
@@ -409,6 +413,25 @@ class SessionTrackingMiddleware(Middleware):
             _persist_session_to_db(session)
 
             return result
+        except NotFoundError as e:
+            new_tool_call.status = "error"
+            new_tool_call.duration_ms = (time.perf_counter() - start_time) * 1000.0
+
+            _persist_session_to_db(session)
+
+            # Return concise not-found message similar to ToolError handling
+            log.warning(f"Tool not found: {context.message.name}: {e}")
+            return ToolResult(
+                content=[
+                    {
+                        "type": "text",
+                        "text": (
+                            f"Tool '{context.message.name}' not found. Please check the tool name or mounted servers."
+                        ),
+                    }
+                ],
+                structured_content=None,
+            )
         except ToolError as e:
             new_tool_call.status = "error"
             new_tool_call.duration_ms = (time.perf_counter() - start_time) * 1000.0

{open_edison-0.1.80rc1 → open_edison-0.1.84rc1}/src/permissions.py

@@ -11,9 +11,9 @@ from functools import cache
 from pathlib import Path
 from typing import Any
 
-from loguru import logger as log
+from loguru import logger as log  # pyright: ignore[reportUnknownVariableType]
 
-from src.config import Config, get_config_dir
+from src.config import Config, ensure_permissions_file, get_config_dir
 
 
 def _default_permissions_dir() -> Path:
@@ -180,24 +180,8 @@ class Permissions:
         permissions: dict[str, Any] = {}
         metadata: PermissionsMetadata | None = None
 
-        if not file_path.exists():
-            # 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
+        # Centralized bootstrap: ensure file exists or create from repo defaults
+        file_path = ensure_permissions_file(file_path)
 
         with open(file_path) as f:
             data: dict[str, Any] = json.load(f)

{open_edison-0.1.80rc1 → open_edison-0.1.84rc1}/src/server.py

@@ -31,7 +31,13 @@ from loguru import logger as log
 from pydantic import BaseModel, Field
 
 from src import events
-from src.config import Config, MCPServerConfig, clear_json_file_cache, get_config_json_path
+from src.config import (
+    Config,
+    MCPServerConfig,
+    clear_json_file_cache,
+    get_config_json_path,
+    resolve_json_path_with_bootstrap,
+)
 from src.config import get_config_dir as _get_cfg_dir  # type: ignore[attr-defined]
 from src.mcp_stdio_capture import (
     install_stdio_client_stderr_capture as _install_stdio_capture,
@@ -209,26 +215,7 @@ class OpenEdisonProxy:
             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) Config directory (preferred)
-            try:
-                base = _get_cfg_dir()
-            except Exception:
-                base = Path.cwd()
-            target = base / filename
-            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 (best effort)
-                with suppress(Exception):
-                    target.parent.mkdir(parents=True, exist_ok=True)
-                    target.write_text(repo_candidate.read_text(encoding="utf-8"), encoding="utf-8")
-                return target if target.exists() else repo_candidate
-
-            # 3) Fall back to config dir path (will be created on save)
-            return target
+            return resolve_json_path_with_bootstrap(filename)
 
         async def _serve_json(filename: str) -> Response:  # type: ignore[override]
             if filename not in allowed_json_files:

{open_edison-0.1.80rc1 → open_edison-0.1.84rc1}/src/setup_tui/main.py

@@ -39,7 +39,9 @@ def show_welcome_screen(*, dry_run: bool = False) -> None:
     print(welcome_text)
 
     # Prompt to continue
-    questionary.confirm("Ready to begin the setup process?", default=True).ask()
+    if not questionary.confirm("Ready to begin the setup process?", default=True).ask():
+        print("Setup aborted. ")
+        sys.exit(1)
 
 
 def handle_mcp_source(  # noqa: C901
@@ -130,6 +132,29 @@ def confirm_configs(configs: list[MCPServerConfig], *, dry_run: bool = False) ->
     ).ask()
 
 
+def select_imported_configs(
+    configs: list[MCPServerConfig], *, dry_run: bool = False
+) -> list[MCPServerConfig]:
+    """Present a checkbox list of imported servers and return the selected subset.
+
+    - Arrow keys to navigate; Space to toggle; Enter to confirm.
+    - Defaults to all selected.
+    """
+    if not configs:
+        return []
+
+    choices = [
+        questionary.Choice(title=config.name, value=config, checked=True) for config in configs
+    ]
+
+    selected = questionary.checkbox(
+        "Select the MCP servers to import (Space to toggle, Enter to confirm):",
+        choices=choices,
+    ).ask()
+
+    return list(selected or [])
+
+
 def confirm_apply_configs(client: CLIENT, *, dry_run: bool = False) -> None:
     if not questionary.confirm(
         f"Would you like to set up Open Edison for {client.name}? (This will modify your MCP configuration. We will make a back up of your current one if you would like to revert.)",
@@ -246,15 +271,24 @@ def run(*, dry_run: bool = False, skip_oauth: bool = False) -> bool:  # noqa: C9
     # Deduplicate configs
     configs = deduplicate_by_name(configs)
 
-    if not confirm_configs(configs, dry_run=dry_run):
-        return False
+    # Let the user select which servers to import
+    selected_configs = select_imported_configs(configs, dry_run=dry_run)
+
+    if len(selected_configs) == 0:
+        if not questionary.confirm(
+            "No MCP servers selected. Continue without importing any?", default=False
+        ).ask():
+            return False
+    else:
+        if not confirm_configs(selected_configs, dry_run=dry_run):
+            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)
+    if len(selected_configs) > 0:
+        save_imported_servers(selected_configs, dry_run=dry_run)
 
     show_manual_setup_screen()
 

{open_edison-0.1.80rc1 → open_edison-0.1.84rc1}/tool_permissions.json

@@ -140,6 +140,16 @@
             "acl": "PUBLIC"
         }
     },
+    "fetch": {
+        "fetch": {
+            "enabled": true,
+            "write_operation": false,
+            "read_private_data": false,
+            "read_untrusted_public_data": true,
+            "acl": "PUBLIC",
+            "description": "Fetch content from a URL (considered untrusted public data)"
+        }
+    },
     "sqlite": {
         "db_info": {
             "enabled": true,