open-edison 0.1.80rc1__py3-none-any.whl → 0.1.84__py3-none-any.whl

{open_edison-0.1.80rc1.dist-info → open_edison-0.1.84.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-edison
-Version: 0.1.80rc1
+Version: 0.1.84
 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.dist-info → open_edison-0.1.84.dist-info}/RECORD

@@ -1,17 +1,18 @@
 src/__init__.py,sha256=bEYMwBiuW9jzF07iWhas4Vb30EcpnqfpNfz_Q6yO1jU,209
 src/__main__.py,sha256=kQsaVyzRa_ESC57JpKDSQJAHExuXme0rM5beJsYxFeA,161
-src/cli.py,sha256=FUq9t5jOjbhdkIX-NhTdiQQs9AZZCH3hi-qPen0XoBk,4740
-src/config.py,sha256=cFbdY55w2JimV6kLv3XDnxDORz533R-GkW0EmKfNqCc,11325
-src/config.pyi,sha256=FgehEGli8ZXSjGlANBgMGv5497q4XskQciOc1fUcxqM,2033
+src/cli.py,sha256=Ki7XCqNlVzUumfELkNM4zGhWB6_ay6ZTlg0pF9wmlWQ,5628
+src/config.py,sha256=wLjU18HzmA34rGD6FII3pTlOQvnY4KcnfoIOZ3QXHhQ,13491
+src/config.pyi,sha256=HJ5l-Kk8W_-qW_4y4kw4aowHSPLf5SOZxB_yJvtmqXc,2260
 src/events.py,sha256=KkhrQ9CE5-WBBCeDkUgdCZURKsXakNP3Kj3gP91NYQM,5046
 src/mcp_stdio_capture.py,sha256=SpMnUqQYm207WpiEwBahUxq4JFG9bnmNkUQVotZX7cc,5458
 src/oauth_manager.py,sha256=qw87VxfRLfvd3YI1EhMmEJJ51N_WJsNpo17GUCvi13c,9971
 src/oauth_override.py,sha256=C7QS8sPA6JqJDiNZA0FGeXcB7jU-yYu-k8V56QVpsqU,393
-src/permissions.py,sha256=G_rCkVRC6yvNEoTe7g6gHXmmnwcmpS6vFScm7bI8oeY,14632
-src/server.py,sha256=H1OtYZcZbOZbcFYb-RljRnDGU-lYrrSNBO2g6ZylnSw,47703
+src/permissions.py,sha256=Tsfxce3qAeswDLAtOx5961oO89wVDoPpID4DPtoumdU,13802
+src/server.py,sha256=ixQLW7FO2xDC3jG1lrTi0_Kpi1-Dgz3x-zM-ztlWq1c,46934
 src/single_user_mcp.py,sha256=veemh0RnwEvvkxI-lA2it8rtnPrCbn3VDR3t4DrE7Kc,25016
 src/telemetry.py,sha256=-RZPIjpI53zbsKmp-63REeZ1JirWHV5WvpSRa2nqZEk,11321
 src/vulture_whitelist.py,sha256=CjBOSsarbzbQt_9ATWc8MbruBsYX3hJVa_ysbRD9ZYM,135
+src/demos/trifecta.py,sha256=y-7ofZ9uu0FZgMGRgDZ2bMQYGbRFSEURk5voJBayOyI,3676
 src/frontend_dist/index.html,sha256=eCG8DLoWNQc5GImBg0Z9dT8HZUMPhAw-4Wc6dEqgKCU,673
 src/frontend_dist/sw.js,sha256=YXwdeSQVg0BaSyhS2REI2DorNEO1kGUn_YCFw14D8VI,3321
 src/frontend_dist/assets/index-D05VN_1l.css,sha256=TVt1HETNMBbfMcrUfYuEE0a-tfpxCsATihxmA8Jp890,17953
@@ -23,19 +24,19 @@ src/mcp_importer/cli.py,sha256=Pe0GLWm1nMd1VuNXOSkxIrFZuGNFc9dNvfBsvf-bdBI,3487
 src/mcp_importer/export_cli.py,sha256=Fw0jDQCI8gGW4BDrJLzWjLUtV4q6v0h2QZ7HF1V2Jcg,6279
 src/mcp_importer/exporters.py,sha256=NsXBa1FvwPmIak0AJUrfbCwhnBIdGc5oXjTtMblFRwk,11345
 src/mcp_importer/import_api.py,sha256=wD5yqxWwFfn1MQNKE79rEeyZODdmPgUDhsRYdCJYh4Q,59
-src/mcp_importer/importers.py,sha256=zGN8lT7qQJ95jDTd-ck09j_w5PSvH-uj33TILoHfHbs,2191
+src/mcp_importer/importers.py,sha256=NSZURilb-pmCZQ6ydyHIoMrZ-18CvREG2UN3MvuX3yY,2677
 src/mcp_importer/merge.py,sha256=KIGT7UgbAm07-LdyoUXEJ7ABSIiPTFlj_qjz669yFxg,1569
-src/mcp_importer/parsers.py,sha256=MDhzODsvX5t1U_CI8byBxCpx6rA4WkpqX4bJMiNE74s,6298
-src/mcp_importer/paths.py,sha256=4L-cPr7KCM9X9gAUP7Da6ictLNrPWuQ_IM419zqY-2I,2700
+src/mcp_importer/parsers.py,sha256=IkLRtoqP9i6rNngb_mNE_YuEoOCMxR2rkyC_DtOgFIg,6366
+src/mcp_importer/paths.py,sha256=JDSB5SLjk16J2qxo921HHUAst0s3EcGlrwqYoruJ11k,3408
 src/mcp_importer/quick_cli.py,sha256=Vv2vjNzpSOaic0YHFbPAuX0nZByawS2kDw6KiCtEX3A,1798
 src/mcp_importer/types.py,sha256=nSaOLGqpCmA3R14QCO6wrpgX75VaLz9HfslUWzw_GPQ,102
 src/middleware/data_access_tracker.py,sha256=ZW-E44U_iOE4jRArRmnQ1HK_zRKs_WZvz4Aa49wXaZk,17105
-src/middleware/session_tracking.py,sha256=_igPVEH_l2hQ5onLb5cdn7MOXNtSxr9USEdJklhM_OA,26984
+src/middleware/session_tracking.py,sha256=cmmeDzI19uQ3WBUbKkIOGfVEDNaFkpI9M2Q3-J3xhGE,27945
 src/setup_tui/__init__.py,sha256=mDFrQoiOtQOHc0sFfGKrNXVLEDeB1S0O5aISBVzfxYo,184
-src/setup_tui/main.py,sha256=9-m5p3HUnENGbfzd7Mk6LI5NjWtgMeXCWtFi65EBsVc,11257
+src/setup_tui/main.py,sha256=Cc1T3qn4V4WST9Q_ToOJLBjP16mZRNFUBmQ9HEkYQHU,12341
 src/tools/io.py,sha256=hhc4pv3eUzYWSZ7BbThclxSMwWBQaGMoGsItIPf_pco,1047
-open_edison-0.1.80rc1.dist-info/METADATA,sha256=c6FKvfS56znCETPDvGrUMDvZVijwxr4lcZK6Aide0bo,11996
-open_edison-0.1.80rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_edison-0.1.80rc1.dist-info/entry_points.txt,sha256=YiGNm9x2I00hgT10HDyB4gxC1LcaV_mu8bXFjolu0Yw,171
-open_edison-0.1.80rc1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-open_edison-0.1.80rc1.dist-info/RECORD,,
+open_edison-0.1.84.dist-info/METADATA,sha256=bwslnOnwoCbrWqN1Omnv5r340Z5kOPG5RpGeVO0f1L4,12031
+open_edison-0.1.84.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+open_edison-0.1.84.dist-info/entry_points.txt,sha256=YiGNm9x2I00hgT10HDyB4gxC1LcaV_mu8bXFjolu0Yw,171
+open_edison-0.1.84.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+open_edison-0.1.84.dist-info/RECORD,,

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)

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

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

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

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

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
 

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:

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

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)

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:

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()