open-edison 0.1.36__tar.gz → 0.1.38__tar.gz

{open_edison-0.1.36 → open_edison-0.1.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-edison
-Version: 0.1.36
+Version: 0.1.38
 Summary: Open-source MCP security, aggregation, and monitoring. Single-user, self-hosted MCP proxy.
 Author-email: Hugo Berg <hugo@edison.watch>
 License-File: LICENSE
@@ -26,7 +26,7 @@ Description-Content-Type: text/markdown
 
 > The Secure MCP Control Panel
 
-Connect AI to your data/software securely without risk of data exfiltration. Gain visibility, block threats, and get alerts on the data your agent is reading/writing. 
+Connect AI to your data/software securely without risk of data exfiltration. Gain visibility, block threats, and get alerts on the data your agent is reading/writing.
 
 OpenEdison solves the [lethal trifecta problem](https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/), which can cause agent hijacking & data exfiltration by malicious actors.
 
@@ -72,6 +72,13 @@ curl -fsSL https://raw.githubusercontent.com/Edison-Watch/open-edison/main/curl_
 
 Run locally with uvx: `uvx open-edison`
 
+Optionally, import your existing MCP configs from Cursor, VS Code, or Claude Code with:
+
+```bash
+# From source (no install) — quick one-liner (add --dry-run to preview)
+uv run python -m mcp_importer.quick_cli --yes
+```
+
 <details>
 <summary>⬇️ Install Node.js/npm (optional for MCP tools)</summary>
 
@@ -121,6 +128,44 @@ OPEN_EDISON_CONFIG_DIR=~/edison-config open-edison run
 
 </details>
 
+<details>
+<summary>🔄 Import from Cursor/VS Code/Claude Code</summary>
+
+### Import from Cursor/VS Code/Claude Code
+
+- **CLI**
+
+  - Import & configure to use edison as your MCP server:
+
+    ```bash
+    # From source (no install)
+    uv run python -m mcp_importer.quick_cli --yes
+    ```
+
+  - Preview what will be imported (no writes):
+
+    ```bash
+    uv run python -m mcp_importer --source cursor --dry-run
+    ```
+
+  - Import servers into Open Edison `config.json` (merge policy defaults to `skip`):
+
+    ```bash
+    uv run python -m mcp_importer --source cursor
+    uv run python -m mcp_importer --source vscode
+    uv run python -m mcp_importer --source claude-code
+    ```
+
+  - Point your editor to Open Edison (backup original config and replace with a single Open Edison server):
+
+    ```bash
+    uv run python -m mcp_importer export --target cursor --yes
+    uv run python -m mcp_importer export --target vscode --yes
+    uv run python -m mcp_importer export --target claude-code --yes
+    ```
+
+</details>
+
 <details>
 <summary><img src="https://img.shields.io/badge/Docker-2CA5E0?style=for-the-badge&logo=docker&logoColor=white" alt="Docker"> Run with Docker</summary>
 

{open_edison-0.1.36 → open_edison-0.1.38}/README.md

@@ -2,7 +2,7 @@
 
 > The Secure MCP Control Panel
 
-Connect AI to your data/software securely without risk of data exfiltration. Gain visibility, block threats, and get alerts on the data your agent is reading/writing. 
+Connect AI to your data/software securely without risk of data exfiltration. Gain visibility, block threats, and get alerts on the data your agent is reading/writing.
 
 OpenEdison solves the [lethal trifecta problem](https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/), which can cause agent hijacking & data exfiltration by malicious actors.
 
@@ -48,6 +48,13 @@ curl -fsSL https://raw.githubusercontent.com/Edison-Watch/open-edison/main/curl_
 
 Run locally with uvx: `uvx open-edison`
 
+Optionally, import your existing MCP configs from Cursor, VS Code, or Claude Code with:
+
+```bash
+# From source (no install) — quick one-liner (add --dry-run to preview)
+uv run python -m mcp_importer.quick_cli --yes
+```
+
 <details>
 <summary>⬇️ Install Node.js/npm (optional for MCP tools)</summary>
 
@@ -97,6 +104,44 @@ OPEN_EDISON_CONFIG_DIR=~/edison-config open-edison run
 
 </details>
 
+<details>
+<summary>🔄 Import from Cursor/VS Code/Claude Code</summary>
+
+### Import from Cursor/VS Code/Claude Code
+
+- **CLI**
+
+  - Import & configure to use edison as your MCP server:
+
+    ```bash
+    # From source (no install)
+    uv run python -m mcp_importer.quick_cli --yes
+    ```
+
+  - Preview what will be imported (no writes):
+
+    ```bash
+    uv run python -m mcp_importer --source cursor --dry-run
+    ```
+
+  - Import servers into Open Edison `config.json` (merge policy defaults to `skip`):
+
+    ```bash
+    uv run python -m mcp_importer --source cursor
+    uv run python -m mcp_importer --source vscode
+    uv run python -m mcp_importer --source claude-code
+    ```
+
+  - Point your editor to Open Edison (backup original config and replace with a single Open Edison server):
+
+    ```bash
+    uv run python -m mcp_importer export --target cursor --yes
+    uv run python -m mcp_importer export --target vscode --yes
+    uv run python -m mcp_importer export --target claude-code --yes
+    ```
+
+</details>
+
 <details>
 <summary><img src="https://img.shields.io/badge/Docker-2CA5E0?style=for-the-badge&logo=docker&logoColor=white" alt="Docker"> Run with Docker</summary>
 

{open_edison-0.1.36 → open_edison-0.1.38}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "open-edison"
-version = "0.1.36"
+version = "0.1.38"
 description = "Open-source MCP security, aggregation, and monitoring. Single-user, self-hosted MCP proxy."
 readme = "README.md"
 authors = [
@@ -28,6 +28,8 @@ requires-python = ">= 3.12"
 [project.scripts]
 open-edison = "src.cli:main"
 open_edison = "src.cli:main"
+mcp-importer = "mcp_importer.__main__:main"
+mcp-importer-quick = "mcp_importer.quick_cli:main"
 
 [build-system]
 requires = ["hatchling"]
@@ -52,7 +54,10 @@ dev-dependencies = [
 allow-direct-references = true
 
 [tool.hatch.build.targets.wheel]
-packages = ["src"]
+packages = ["src", "src/mcp_importer"]
+exclude = [
+  "src/mcp_importer/**",
+]
 include = [
   "README.md",
   "LICENSE",

open_edison-0.1.38/src/__init__.py

@@ -0,0 +1,8 @@
+"""
+Open Edison Source Package.
+
+Note: Avoid importing heavy submodules at package import time to keep
+packaging/import of light utilities (e.g., mcp_importer) side‑effect free.
+"""
+
+__all__: list[str] = []

open_edison-0.1.38/src/mcp_importer/__init__.py

@@ -0,0 +1,15 @@
+"""MCP importer package for Open Edison scripts.
+
+Import submodules explicitly as needed, e.g. `from mcp_importer import cli`.
+"""
+
+# pyright: reportUnsupportedDunderAll=false
+
+__all__ = [
+    "paths",
+    "parsers",
+    "importers",
+    "merge",
+    "cli",
+    "api",
+]

open_edison-0.1.38/src/mcp_importer/__main__.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import sys
+
+from mcp_importer.cli import run_cli as import_run_cli
+from mcp_importer.export_cli import run_cli as export_run_cli
+
+
+def main() -> int:
+    # Usage:
+    #   python -m mcp_importer            -> import CLI
+    #   python -m mcp_importer export ... -> export CLI
+    if len(sys.argv) > 1 and sys.argv[1] == "export":
+        return export_run_cli(sys.argv[2:])
+    return import_run_cli(sys.argv[1:])
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

open_edison-0.1.38/src/mcp_importer/api.py

@@ -0,0 +1,106 @@
+# pyright: reportMissingImports=false, reportUnknownVariableType=false, reportUnknownMemberType=false, reportUnknownArgumentType=false, reportUnknownParameterType=false
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+import mcp_importer.paths as _paths
+from mcp_importer.exporters import export_to_claude_code, export_to_cursor, export_to_vscode
+from mcp_importer.importers import (
+    import_from_claude_code as _import_from_claude_code,
+)
+from mcp_importer.importers import (
+    import_from_cursor as _import_from_cursor,
+)
+from mcp_importer.importers import (
+    import_from_vscode as _import_from_vscode,
+)
+from mcp_importer.merge import MergePolicy, merge_servers
+from src.config import Config, MCPServerConfig, get_config_json_path
+
+
+class CLIENT(str, Enum):
+    CURSOR = "cursor"
+    VSCODE = "vscode"
+    CLAUDE_CODE = "claude-code"
+
+
+def detect_clients() -> set[CLIENT]:
+    detected: set[CLIENT] = set()
+    if _paths.detect_cursor_config_path() is not None:
+        detected.add(CLIENT.CURSOR)
+    if _paths.detect_vscode_config_path() is not None:
+        detected.add(CLIENT.VSCODE)
+    if _paths.detect_claude_code_config_path() is not None:
+        detected.add(CLIENT.CLAUDE_CODE)
+    return detected
+
+
+import_cursor = _import_from_cursor
+import_vscode = _import_from_vscode
+import_claude_code = _import_from_claude_code
+
+
+def import_from(client: CLIENT) -> list[MCPServerConfig]:
+    if client == CLIENT.CURSOR:
+        return import_cursor()
+    if client == CLIENT.VSCODE:
+        return import_vscode()
+    if client == CLIENT.CLAUDE_CODE:
+        return import_claude_code()
+    raise ValueError(f"Unsupported client: {client}")
+
+
+def save_imported_servers(
+    servers: list[MCPServerConfig],
+    *,
+    merge_policy: str = MergePolicy.SKIP,
+    config_dir: Path | None = None,
+) -> Path:
+    target_path: Path = (
+        get_config_json_path() if config_dir is None else (Path(config_dir) / "config.json")
+    )
+    cfg: Config = Config(target_path)
+    merged = merge_servers(existing=cfg.mcp_servers, imported=servers, policy=merge_policy)
+    cfg.mcp_servers = merged
+    cfg.save(target_path)
+    return target_path
+
+
+def export_edison_to(
+    client: CLIENT,
+    *,
+    url: str = "http://localhost:3000/mcp/",
+    api_key: str = "dev-api-key-change-me",
+    server_name: str = "open-edison",
+    dry_run: bool = False,
+    force: bool = False,
+    create_if_missing: bool = False,
+) -> Any:
+    match client:
+        case CLIENT.CURSOR:
+            return export_to_cursor(
+                url=url,
+                api_key=api_key,
+                server_name=server_name,
+                dry_run=dry_run,
+                force=force,
+                create_if_missing=create_if_missing,
+            )
+        case CLIENT.VSCODE:
+            return export_to_vscode(
+                url=url,
+                api_key=api_key,
+                server_name=server_name,
+                dry_run=dry_run,
+                force=force,
+                create_if_missing=create_if_missing,
+            )
+        case CLIENT.CLAUDE_CODE:
+            return export_to_claude_code(
+                url=url,
+                api_key=api_key,
+                server_name=server_name,
+                dry_run=dry_run,
+                force=force,
+                create_if_missing=create_if_missing,
+            )

open_edison-0.1.38/src/mcp_importer/cli.py

@@ -0,0 +1,113 @@
+# pyright: reportMissingImports=false, reportUnknownVariableType=false, reportUnknownArgumentType=false, reportUnknownMemberType=false, reportUnknownParameterType=false
+import argparse
+import sys
+from pathlib import Path
+
+from loguru import logger as log
+
+from src.config import Config, get_config_dir
+
+from .importers import IMPORTERS
+from .merge import MergePolicy, merge_servers
+
+## Ensure import of src config (place src on sys.path before import)
+# THIS_FILE = Path(__file__).resolve()
+# REPO_ROOT = THIS_FILE.parents[2]
+# SRC_DIR = REPO_ROOT / "src"
+# if str(SRC_DIR) not in sys.path:
+#    sys.path.insert(0, str(SRC_DIR))
+
+
+def build_arg_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        description="Import MCP servers from other tools into Open Edison config.json"
+    )
+    p.add_argument(
+        "--source",
+        choices=["cursor", "vscode", "claude-code"],
+        required=True,
+    )
+    p.add_argument(
+        "--config-dir",
+        type=Path,
+        help="Directory containing target config.json (default: OPEN_EDISON_CONFIG_DIR or repo root)",
+    )
+    p.add_argument(
+        "--merge",
+        choices=[MergePolicy.SKIP, MergePolicy.OVERWRITE, MergePolicy.RENAME],
+        default=MergePolicy.SKIP,
+    )
+    p.add_argument(
+        "--dry-run", action="store_true", help="Show changes without writing to config.json"
+    )
+    return p
+
+
+def run_cli(argv: list[str] | None = None) -> int:  # noqa: C901
+    parser = build_arg_parser()
+    args = parser.parse_args(argv)
+
+    source: str = args.source
+
+    importer = IMPORTERS.get(source)
+    if not importer:
+        print(f"Unsupported source: {source}", file=sys.stderr)
+        return 2
+
+    # Resolve target config path
+    target_dir: Path = args.config_dir or get_config_dir()
+    target_path = target_dir / "config.json"
+
+    # Load existing config (auto-creates default if missing via Config.load)
+    config_obj: Config = Config(target_dir)
+
+    # Import
+    imported_servers = importer()
+
+    if not imported_servers:
+        log.warning("No servers found to import from source '{}'", source)
+        return 0
+
+    # Merge
+    merged = merge_servers(
+        existing=config_obj.mcp_servers,
+        imported=imported_servers,
+        policy=args.merge,
+    )
+
+    existing_names: set[str] = {str(getattr(s, "name", "")) for s in config_obj.mcp_servers}
+    merged_names: set[str] = {str(getattr(s, "name", "")) for s in merged}
+    added = merged_names - existing_names
+    replaced: set[str] = set()
+    if args.merge == MergePolicy.OVERWRITE:
+        replaced = existing_names & {s.name for s in imported_servers}
+
+    log.info("Imported {} server(s) from '{}'", len(imported_servers), source)
+    try:
+        names_preview = ", ".join(sorted(getattr(s, "name", "") for s in imported_servers))
+        if names_preview:
+            log.info("Detected servers: {}", names_preview)
+    except Exception:
+        pass
+    if added:
+        log.info("Added: {}", ", ".join(sorted(added)))
+    if replaced:
+        log.info("Overwrote: {}", ", ".join(sorted(replaced)))
+
+    if args.dry_run:
+        log.info("Dry-run enabled; not writing changes to {}", target_path)
+        log.debug("Merged servers: {}", merged)
+        return 0
+
+    config_obj.mcp_servers = merged
+    config_obj.save(target_path)
+    log.info("Configuration updated: {}", target_path)
+    return 0
+
+
+def main() -> int:
+    return run_cli()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

open_edison-0.1.38/src/mcp_importer/export_cli.py

@@ -0,0 +1,201 @@
+import argparse
+from pathlib import Path
+
+from loguru import logger as log
+
+from .exporters import ExportError, export_to_claude_code, export_to_cursor, export_to_vscode
+from .paths import (
+    detect_cursor_config_path,
+    detect_vscode_config_path,
+    get_default_cursor_config_path,
+    get_default_vscode_config_path,
+)
+
+
+def _prompt_yes_no(message: str, *, default_no: bool = True) -> bool:
+    suffix = "[y/N]" if default_no else "[Y/n]"
+    while True:
+        resp = input(f"{message} {suffix} ").strip().lower()
+        if resp == "y" or resp == "yes":
+            return True
+        if resp == "n" or resp == "no":
+            return False
+        if resp == "" and default_no:
+            return False
+        if resp == "" and not default_no:
+            return True
+
+
+def build_arg_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        description="Export editor MCP config to use Open Edison (Cursor support)",
+    )
+    p.add_argument("--target", choices=["cursor", "vscode", "claude-code"], default="cursor")
+    p.add_argument("--dry-run", action="store_true", help="Show actions without writing")
+    p.add_argument("--force", action="store_true", help="Rewrite even if already configured")
+    p.add_argument(
+        "--yes",
+        action="store_true",
+        help="Automatic yes to prompts (create missing files without confirmation)",
+    )
+    p.add_argument("--url", default="http://localhost:3000/mcp/", help="MCP URL")
+    p.add_argument(
+        "--api-key",
+        default="dev-api-key-change-me",
+        help="API key for Authorization header",
+    )
+    p.add_argument("--name", default="open-edison", help="Name of the server entry")
+    return p
+
+
+def _handle_cursor(args: argparse.Namespace) -> int:
+    detected = detect_cursor_config_path()
+    target_path: Path = detected if detected else get_default_cursor_config_path()
+
+    create_if_missing = False
+    if not target_path.exists():
+        if args.yes:
+            create_if_missing = True
+        else:
+            confirmed = _prompt_yes_no(
+                f"Cursor config not found at {target_path}. Create it?", default_no=False
+            )
+            if not confirmed:
+                log.info("Aborted: user declined to create missing file")
+                return 0
+            create_if_missing = True
+
+    try:
+        result = export_to_cursor(
+            url=args.url,
+            api_key=args.api_key,
+            server_name=args.name,
+            dry_run=args.dry_run,
+            force=args.force,
+            create_if_missing=create_if_missing,
+        )
+    except ExportError as e:
+        log.error(str(e))
+        return 1
+
+    if result.dry_run:
+        log.info("Dry-run complete. No changes written.")
+        return 0
+
+    if result.wrote_changes:
+        if result.backup_path is not None:
+            log.info("Backup created at {}", result.backup_path)
+        log.info("Updated {}", result.target_path)
+    else:
+        log.info("No changes were necessary.")
+    return 0
+
+
+def _handle_vscode(args: argparse.Namespace) -> int:
+    detected = detect_vscode_config_path()
+    target_path: Path = detected if detected else get_default_vscode_config_path()
+
+    create_if_missing = False
+    if not target_path.exists():
+        if args.yes:
+            create_if_missing = True
+        else:
+            confirmed = _prompt_yes_no(
+                f"VS Code MCP config not found at {target_path}. Create it?", default_no=False
+            )
+            if not confirmed:
+                log.info("Aborted: user declined to create missing file")
+                return 0
+            create_if_missing = True
+
+    try:
+        result = export_to_vscode(
+            url=args.url,
+            api_key=args.api_key,
+            server_name=args.name,
+            dry_run=args.dry_run,
+            force=args.force,
+            create_if_missing=create_if_missing,
+        )
+    except ExportError as e:
+        log.error(str(e))
+        return 1
+
+    if result.dry_run:
+        log.info("Dry-run complete. No changes written.")
+        return 0
+
+    if result.wrote_changes:
+        if result.backup_path is not None:
+            log.info("Backup created at {}", result.backup_path)
+        log.info("Updated {}", result.target_path)
+    else:
+        log.info("No changes were necessary.")
+    return 0
+
+
+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()
+
+    create_if_missing = False
+    if not target_path.exists():
+        if args.yes:
+            create_if_missing = True
+        else:
+            confirmed = _prompt_yes_no(
+                f"Claude Code config not found at {target_path}. Create it?", default_no=False
+            )
+            if not confirmed:
+                log.info("Aborted: user declined to create missing file")
+                return 0
+            create_if_missing = True
+
+    try:
+        result = export_to_claude_code(
+            url=args.url,
+            api_key=args.api_key,
+            server_name=args.name,
+            dry_run=args.dry_run,
+            force=args.force,
+            create_if_missing=create_if_missing,
+        )
+    except ExportError as e:
+        log.error(str(e))
+        return 1
+
+    if result.dry_run:
+        log.info("Dry-run complete. No changes written.")
+        return 0
+
+    if result.wrote_changes:
+        if result.backup_path is not None:
+            log.info("Backup created at {}", result.backup_path)
+        log.info("Updated {}", result.target_path)
+    else:
+        log.info("No changes were necessary.")
+    return 0
+
+
+def run_cli(argv: list[str] | None = None) -> int:
+    parser = build_arg_parser()
+    args = parser.parse_args(argv)
+
+    if args.target == "cursor":
+        return _handle_cursor(args)
+    if args.target == "vscode":
+        return _handle_vscode(args)
+    if args.target == "claude-code":
+        return _handle_claude_code(args)
+    log.error("Unsupported target: {}", args.target)
+    return 2
+
+
+def main() -> int:
+    return run_cli()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())