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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-edison
-Version: 0.1.84rc1
+Version: 0.1.85rc1
 Summary: Open-source MCP security, aggregation, and monitoring. Single-user, self-hosted MCP proxy.
 Author-email: Hugo Berg <hugo@edison.watch>
 License-File: LICENSE

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

@@ -1,6 +1,6 @@
 [project]
 name = "open-edison"
-version = "0.1.84rc1"
+version = "0.1.85rc1"
 description = "Open-source MCP security, aggregation, and monitoring. Single-user, self-hosted MCP proxy."
 readme = "README.md"
 authors = [

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

@@ -14,6 +14,7 @@ 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.api import detect_clients, restore_client
 from src.mcp_importer.cli import run_cli
 from src.server import OpenEdisonProxy
 from src.setup_tui.main import run_import_tui
@@ -106,6 +107,21 @@ def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
         ),
     )
 
+    # restore-clients: restore editor configs from backups or remove OE-only config
+    sp_restore = subparsers.add_parser(
+        "restore-clients",
+        help="Restore backed up MCP client configs (Cursor, VS Code, Claude Code)",
+        description=(
+            "Detect installed clients and restore their MCP config from the most recent backup, "
+            "or remove the Open Edison-only MCP entry if no backup is present."
+        ),
+    )
+    sp_restore.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview restore operations without writing",
+    )
+
     return parser.parse_args(argv)
 
 
@@ -158,6 +174,41 @@ def main(argv: list[str] | None = None) -> NoReturn:  # noqa: C901
             asyncio.run(_run_server(args))
         raise SystemExit(0)
 
+    if args.command == "restore-clients":
+        # Detect clients and prompt user per client
+        available = sorted(detect_clients(), key=lambda c: c.value)
+        if not available:
+            log.info("No supported MCP clients detected")
+            raise SystemExit(0)
+        from questionary import confirm
+
+        for client in available:
+            if not confirm(
+                f"Restore original MCP config for {client.value}? (removes Open Edison)", default=True
+            ).ask():
+                continue
+            try:
+                res = restore_client(client, dry_run=getattr(args, "dry_run", False))
+                if getattr(args, "dry_run", False):
+                    log.info("[dry-run] {}: would restore at {}", client.value, res.target_path)
+                else:
+                    if res.restored_from_backup is not None:
+                        log.info(
+                            "Restored {} from backup {}", client.value, res.restored_from_backup
+                        )
+                    elif res.removed_open_edison_only:
+                        log.info(
+                            "Removed Open Edison-only entry from {} at {}",
+                            client.value,
+                            res.target_path,
+                        )
+                    else:
+                        log.info("No restore action taken for {}", client.value)
+            except Exception as e:
+                log.error(f"Restore failed for {client.value}: {e}")
+                raise SystemExit(1) from e
+        raise SystemExit(0)
+
     # Run import tui if necessary
     tui_success = run_import_tui(args, force=args.wizard_force)
     if not tui_success:

{open_edison-0.1.84rc1 → open_edison-0.1.85rc1}/src/mcp_importer/api.py

@@ -15,9 +15,13 @@ from src.config import Config, MCPServerConfig, get_config_json_path
 from src.mcp_importer import paths as _paths
 from src.mcp_importer.exporters import (
     ExportResult,
+    RestoreResult,
     export_to_claude_code,
     export_to_cursor,
     export_to_vscode,
+    restore_claude_code,
+    restore_cursor,
+    restore_vscode,
 )
 from src.mcp_importer.importers import (
     import_from_claude_code,
@@ -135,6 +139,23 @@ def export_edison_to(
             )
 
 
+def restore_client(
+    client: CLIENT,
+    *,
+    server_name: str = "open-edison",
+    dry_run: bool = False,
+) -> RestoreResult:
+    if dry_run:
+        print(f"[dry-run] Would restore original MCP config for '{client}' (using latest backup if present)")
+    match client:
+        case CLIENT.CURSOR:
+            return restore_cursor(server_name=server_name, dry_run=dry_run)
+        case CLIENT.VSCODE:
+            return restore_vscode(server_name=server_name, dry_run=dry_run)
+        case CLIENT.CLAUDE_CODE:
+            return restore_claude_code(server_name=server_name, dry_run=dry_run)
+
+
 def verify_mcp_server(server: MCPServerConfig) -> bool:  # noqa
     """Minimal validation: try listing tools/resources/prompts via FastMCP within a timeout."""
 

{open_edison-0.1.84rc1 → open_edison-0.1.85rc1}/src/mcp_importer/exporters.py

@@ -5,7 +5,7 @@ import tempfile
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 from loguru import logger as log
 
@@ -63,7 +63,8 @@ def _read_json_or_error(path: Path) -> dict[str, Any]:
         raise ExportError(f"Malformed JSON at {path}: {e}") from e
     if not isinstance(data, dict):
         raise ExportError(f"Expected top-level JSON object at {path}")
-    return data
+    typed_data: dict[str, Any] = cast(dict[str, Any], data)
+    return typed_data
 
 
 def _require_supported_os() -> None:
@@ -188,21 +189,25 @@ def _build_open_edison_server(
 def _is_already_open_edison(
     config_obj: dict[str, Any], *, url: str, api_key: str, name: str
 ) -> bool:
-    servers_node = config_obj.get("mcpServers") or config_obj.get("servers")
-    if not isinstance(servers_node, dict):
+    servers_raw: Any = config_obj.get("mcpServers") or config_obj.get("servers")
+    if not isinstance(servers_raw, dict):
         return False
+    servers_node: dict[str, Any] = cast(dict[str, Any], servers_raw)
     # Must be exactly one server
     if len(servers_node) != 1:
         return False
-    only_name, only_spec = next(iter(servers_node.items()))
-    if only_name != name or not isinstance(only_spec, dict):
+    only_name, only_spec_any = next(iter(servers_node.items()))
+    if only_name != name or not isinstance(only_spec_any, dict):
         return False
-    if only_spec.get("command") != "npx":
+    only_spec: dict[str, Any] = cast(dict[str, Any], only_spec_any)
+    cmd_val_any: Any = only_spec.get("command")
+    if cmd_val_any != "npx":
         return False
-    args = only_spec.get("args")
-    if not isinstance(args, list):
+    args_obj_any: Any = only_spec.get("args")
+    if not isinstance(args_obj_any, list):
         return False
-    args_str = [str(a) for a in args]
+    args_list: list[Any] = cast(list[Any], args_obj_any)
+    args_str = [str(a) for a in args_list]
     expected_header = f"Authorization: Bearer {api_key}"
     return (
         url in args_str
@@ -213,6 +218,163 @@ def _is_already_open_edison(
     )
 
 
+# --- Restore helpers and functions ---
+
+
+@dataclass
+class RestoreResult:
+    target_path: Path
+    restored_from_backup: Path | None
+    wrote_changes: bool
+    dry_run: bool
+    removed_open_edison_only: bool
+
+
+def _find_latest_backup(target_path: Path) -> Path | None:
+    parent = target_path.parent
+    prefix = target_path.name + ".bak-"
+    candidates: list[Path] = [p for p in parent.glob(target_path.name + ".bak-*") if p.is_file()]
+    if not candidates:
+        return None
+    # Sort by timestamp portion descending (string sort works with our format)
+    def _key(p: Path) -> str:
+        return p.name.replace(prefix, "")
+
+    candidates.sort(key=_key, reverse=True)
+    return candidates[0]
+
+
+def _is_open_edison_singleton(config_obj: dict[str, Any], *, name: str) -> bool:
+    servers_raw: Any = config_obj.get("mcpServers") or config_obj.get("servers")
+    if not isinstance(servers_raw, dict):
+        return False
+    servers_node: dict[str, Any] = cast(dict[str, Any], servers_raw)
+    if len(servers_node) != 1:
+        return False
+    only_name, only_spec_any = next(iter(servers_node.items()))
+    if only_name != name or not isinstance(only_spec_any, dict):
+        return False
+    only_spec: dict[str, Any] = cast(dict[str, Any], only_spec_any)
+    cmd_val_any: Any = only_spec.get("command")
+    if cmd_val_any != "npx":
+        return False
+    args_obj_any: Any = only_spec.get("args")
+    if not isinstance(args_obj_any, list):
+        return False
+    args_list: list[Any] = cast(list[Any], args_obj_any)
+    args_str = [str(a) for a in args_list]
+    return "mcp-remote" in args_str
+
+
+def _restore_from_backup_or_remove(
+    *,
+    target_path: Path,
+    label: str,
+    key_name: str,
+    server_name: str,
+    dry_run: bool,
+) -> RestoreResult:
+    backup = _find_latest_backup(target_path)
+    if backup is not None:
+        if dry_run:
+            log.info("[dry-run] Would restore {} from backup {}", label, backup)
+            return RestoreResult(
+                target_path=target_path,
+                restored_from_backup=backup,
+                wrote_changes=False,
+                dry_run=True,
+                removed_open_edison_only=False,
+            )
+        _ensure_parent_dir(target_path)
+        shutil.copy2(backup, target_path)
+        log.info("Restored {} from backup {}", label, backup)
+        return RestoreResult(
+            target_path=target_path,
+            restored_from_backup=backup,
+            wrote_changes=True,
+            dry_run=False,
+            removed_open_edison_only=False,
+        )
+
+    # No backup found; as a safety, remove the Open Edison-only MCP section if it exactly matches
+    if not target_path.exists():
+        return RestoreResult(
+            target_path=target_path,
+            restored_from_backup=None,
+            wrote_changes=False,
+            dry_run=dry_run,
+            removed_open_edison_only=False,
+        )
+    current = _read_json_or_error(target_path)
+    if _is_open_edison_singleton(current, name=server_name):
+        if dry_run:
+            log.info("[dry-run] Would remove Open Edison-only MCP section from {}", label)
+            return RestoreResult(
+                target_path=target_path,
+                restored_from_backup=None,
+                wrote_changes=False,
+                dry_run=True,
+                removed_open_edison_only=True,
+            )
+        if key_name in current:
+            # Remove entire MCP section
+            current.pop(key_name, None)
+        _atomic_write_json(target_path, current)
+        log.info("Removed Open Edison-only MCP section from {}", label)
+        return RestoreResult(
+            target_path=target_path,
+            restored_from_backup=None,
+            wrote_changes=True,
+            dry_run=False,
+            removed_open_edison_only=True,
+        )
+    # Nothing to do
+    return RestoreResult(
+        target_path=target_path,
+        restored_from_backup=None,
+        wrote_changes=False,
+        dry_run=dry_run,
+        removed_open_edison_only=False,
+    )
+
+
+def restore_cursor(*, server_name: str = "open-edison", dry_run: bool = False) -> RestoreResult:
+    _require_supported_os()
+    target_path = _resolve_cursor_target()
+    return _restore_from_backup_or_remove(
+        target_path=target_path,
+        label="Cursor",
+        key_name="mcpServers",
+        server_name=server_name,
+        dry_run=dry_run,
+    )
+
+
+def restore_vscode(*, server_name: str = "open-edison", dry_run: bool = False) -> RestoreResult:
+    _require_supported_os()
+    target_path = _resolve_vscode_target()
+    return _restore_from_backup_or_remove(
+        target_path=target_path,
+        label="VS Code",
+        key_name="servers",
+        server_name=server_name,
+        dry_run=dry_run,
+    )
+
+
+def restore_claude_code(*, server_name: str = "open-edison", dry_run: bool = False) -> RestoreResult:
+    _require_supported_os()
+    target_path = _resolve_claude_code_target()
+    # Claude Code uses general settings format; MCP key is "mcpServers"
+    return _restore_from_backup_or_remove(
+        target_path=target_path,
+        label="Claude Code",
+        key_name="mcpServers",
+        server_name=server_name,
+        dry_run=dry_run,
+    )
+
+
 def export_to_cursor(
     *,
     url: str = "http://localhost:3000/mcp/",
@@ -378,7 +540,7 @@ def export_to_claude_code(
         current = {}
 
     new_mcp = _build_open_edison_server(name=server_name, url=url, api_key=api_key)
-    if is_existing and isinstance(current, dict) and current:
+    if is_existing and current:
         new_config = _merge_preserving_non_mcp(current, new_mcp)
     else:
         new_config = {"mcpServers": new_mcp}