open-edison 0.1.39__py3-none-any.whl → 0.1.40__py3-none-any.whl

src/mcp_importer/exporters.py

@@ -0,0 +1,393 @@
+import json
+import os
+import shutil
+import tempfile
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from loguru import logger as log
+
+from .paths import (
+    find_claude_code_user_all_candidates,
+    find_cursor_user_file,
+    find_vscode_user_mcp_file,
+    is_macos,
+    is_windows,
+)
+
+
+@dataclass
+class ExportResult:
+    target_path: Path
+    backup_path: Path | None
+    wrote_changes: bool
+    dry_run: bool
+
+
+class ExportError(Exception):
+    pass
+
+
+def _timestamp() -> str:
+    return datetime.now().strftime("%Y%m%d-%H%M%S")
+
+
+def _ensure_parent_dir(path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+
+def _atomic_write_json(path: Path, data: dict[str, Any]) -> None:
+    _ensure_parent_dir(path)
+    tmp_fd, tmp_path = tempfile.mkstemp(prefix=path.name + ".", dir=str(path.parent))
+    try:
+        with os.fdopen(tmp_fd, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+            f.write("\n")
+        # Use replace to be atomic on POSIX
+        Path(tmp_path).replace(path)
+    finally:
+        try:
+            if Path(tmp_path).exists():
+                Path(tmp_path).unlink(missing_ok=True)
+        except Exception:
+            pass
+
+
+def _read_json_or_error(path: Path) -> dict[str, Any]:
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+    except Exception as e:
+        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
+
+
+def _require_supported_os() -> None:
+    if is_windows():
+        raise ExportError("Windows is not supported. Use macOS or Linux.")
+
+
+def _resolve_cursor_target() -> Path:
+    existing = find_cursor_user_file()
+    return existing[0] if existing else (Path.home() / ".cursor" / "mcp.json").resolve()
+
+
+def _resolve_vscode_target() -> Path:
+    existing = find_vscode_user_mcp_file()
+    if existing:
+        return existing[0]
+    if is_macos():
+        return (
+            Path.home() / "Library" / "Application Support" / "Code" / "User" / "mcp.json"
+        ).resolve()
+    return (Path.home() / ".config" / "Code" / "User" / "mcp.json").resolve()
+
+
+def _resolve_claude_code_target() -> Path:
+    existing = find_claude_code_user_all_candidates()
+    if existing:
+        return existing[0]
+    return (Path.home() / ".claude.json").resolve()
+
+
+def _validate_or_confirm_create(target_path: Path, *, create_if_missing: bool, label: str) -> None:
+    if target_path.exists():
+        _read_json_or_error(target_path)
+        return
+    if not create_if_missing:
+        raise ExportError(
+            f"{label} config not found at {target_path}. Refusing to create without confirmation."
+        )
+
+
+def _skip_if_already_configured(
+    target_path: Path,
+    *,
+    url: str,
+    api_key: str,
+    name: str,
+    force: bool,
+    dry_run: bool,
+    label: str,
+) -> ExportResult | None:
+    if not target_path.exists():
+        return None
+    current = _read_json_or_error(target_path)
+    if _is_already_open_edison(current, url=url, api_key=api_key, name=name) and not force:
+        log.info(
+            "{} is already configured to use Open Edison. Skipping (use --force to rewrite).", label
+        )
+        return ExportResult(
+            target_path=target_path, backup_path=None, wrote_changes=False, dry_run=dry_run
+        )
+    return None
+
+
+def _backup_if_exists(target_path: Path, *, dry_run: bool) -> Path | None:
+    if not target_path.exists():
+        return None
+    backup_path = target_path.with_name(target_path.name + f".bak-{_timestamp()}")
+    if dry_run:
+        log.info("[dry-run] Would back up {} -> {}", target_path, backup_path)
+        return backup_path
+    _ensure_parent_dir(backup_path)
+    shutil.copy2(target_path, backup_path)
+    log.info("Backed up {} -> {}", target_path, backup_path)
+    return backup_path
+
+
+def _write_config(
+    target_path: Path,
+    *,
+    new_config: dict[str, Any],
+    backup_path: Path | None,
+    dry_run: bool,
+    label: str,
+) -> ExportResult:
+    if dry_run:
+        log.info("[dry-run] Would write minimal {} MCP config to {}", label, target_path)
+        log.debug("[dry-run] New JSON: {}", json.dumps(new_config, indent=2))
+        return ExportResult(
+            target_path=target_path, backup_path=backup_path, wrote_changes=False, dry_run=True
+        )
+    _atomic_write_json(target_path, new_config)
+    log.info("Wrote {} MCP config to {}", label, target_path)
+    return ExportResult(
+        target_path=target_path, backup_path=backup_path, wrote_changes=True, dry_run=False
+    )
+
+
+def _build_open_edison_server(
+    *,
+    name: str,
+    url: str,
+    api_key: str,
+) -> dict[str, Any]:
+    return {
+        name: {
+            "command": "npx",
+            "args": [
+                "-y",
+                "mcp-remote",
+                url,
+                "--header",
+                f"Authorization: Bearer {api_key}",
+                "--transport",
+                "http-only",
+                "--allow-http",
+            ],
+            "enabled": True,
+        }
+    }
+
+
+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):
+        return False
+    # 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):
+        return False
+    if only_spec.get("command") != "npx":
+        return False
+    args = only_spec.get("args")
+    if not isinstance(args, list):
+        return False
+    args_str = [str(a) for a in args]
+    expected_header = f"Authorization: Bearer {api_key}"
+    return (
+        url in args_str
+        and expected_header in args_str
+        and "mcp-remote" in args_str
+        and "--transport" in args_str
+        and "http-only" in args_str
+    )
+
+
+def export_to_cursor(
+    *,
+    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,
+) -> ExportResult:
+    """Export editor config for Cursor to point solely to Open Edison.
+
+    Behavior:
+    - Back up existing file if present.
+    - Abort on malformed JSON.
+    - If file does not exist, require create_if_missing=True or raise ExportError.
+    - Write a minimal mcpServers object with a single Open Edison server.
+    - Atomic writes.
+    """
+
+    _require_supported_os()
+    target_path = _resolve_cursor_target()
+
+    backup_path: Path | None = None
+
+    _validate_or_confirm_create(target_path, create_if_missing=create_if_missing, label="Cursor")
+
+    # Build the minimal config
+    new_config: dict[str, Any] = {
+        "mcpServers": _build_open_edison_server(name=server_name, url=url, api_key=api_key)
+    }
+
+    # If already configured exactly as desired and not forcing, no-op
+    maybe_skip = _skip_if_already_configured(
+        target_path,
+        url=url,
+        api_key=api_key,
+        name=server_name,
+        force=force,
+        dry_run=dry_run,
+        label="Cursor",
+    )
+    if maybe_skip is not None:
+        return maybe_skip
+
+    # Prepare backup if file exists
+    backup_path = _backup_if_exists(target_path, dry_run=dry_run)
+
+    # Write new config
+    return _write_config(
+        target_path,
+        new_config=new_config,
+        backup_path=backup_path,
+        dry_run=dry_run,
+        label="Cursor",
+    )
+
+
+def export_to_vscode(
+    *,
+    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,
+) -> ExportResult:
+    """Export editor config for VS Code to point solely to Open Edison.
+
+    Uses the user-level `mcp.json` path used by the importer.
+
+    Behavior mirrors Cursor export:
+    - Back up existing file if present.
+    - Abort on malformed JSON.
+    - If file does not exist, require create_if_missing=True or raise ExportError.
+    - Write a minimal mcpServers object with a single Open Edison server.
+    - Atomic writes.
+    """
+
+    _require_supported_os()
+    target_path = _resolve_vscode_target()
+
+    backup_path: Path | None = None
+
+    _validate_or_confirm_create(target_path, create_if_missing=create_if_missing, label="VS Code")
+
+    # Build the minimal config
+    new_config: dict[str, Any] = {
+        "mcpServers": _build_open_edison_server(name=server_name, url=url, api_key=api_key)
+    }
+
+    # If already configured exactly as desired and not forcing, no-op
+    maybe_skip = _skip_if_already_configured(
+        target_path,
+        url=url,
+        api_key=api_key,
+        name=server_name,
+        force=force,
+        dry_run=dry_run,
+        label="VS Code",
+    )
+    if maybe_skip is not None:
+        return maybe_skip
+
+    # Prepare backup if file exists
+    backup_path = _backup_if_exists(target_path, dry_run=dry_run)
+
+    # Write new config
+    return _write_config(
+        target_path,
+        new_config=new_config,
+        backup_path=backup_path,
+        dry_run=dry_run,
+        label="VS Code",
+    )
+
+
+def _merge_preserving_non_mcp(
+    existing_obj: dict[str, Any], new_mcp: dict[str, Any]
+) -> dict[str, Any]:
+    merged = dict(existing_obj)
+    merged.pop("servers", None)
+    merged["mcpServers"] = new_mcp
+    return merged
+
+
+def export_to_claude_code(
+    *,
+    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,
+) -> ExportResult:
+    """Export for Claude Code.
+
+    - If target is a general settings file, preserve non-MCP keys and replace MCP.
+    - Otherwise, write minimal MCP-only object.
+    """
+
+    _require_supported_os()
+    target_path = _resolve_claude_code_target()
+
+    is_existing = target_path.exists()
+    if is_existing:
+        current = _read_json_or_error(target_path)
+        maybe_skip = _skip_if_already_configured(
+            target_path,
+            url=url,
+            api_key=api_key,
+            name=server_name,
+            force=force,
+            dry_run=dry_run,
+            label="Claude Code",
+        )
+        if maybe_skip is not None:
+            return maybe_skip
+    else:
+        if not create_if_missing:
+            raise ExportError(
+                f"Claude Code config not found at {target_path}. Refusing to create without confirmation."
+            )
+        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:
+        new_config = _merge_preserving_non_mcp(current, new_mcp)
+    else:
+        new_config = {"mcpServers": new_mcp}
+
+    backup_path = _backup_if_exists(target_path, dry_run=dry_run)
+    return _write_config(
+        target_path,
+        new_config=new_config,
+        backup_path=backup_path,
+        dry_run=dry_run,
+        label="Claude Code",
+    )

src/mcp_importer/import_api.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+# legacy helpers were removed to satisfy deadcode scanning

src/mcp_importer/importers.py

@@ -0,0 +1,63 @@
+from collections.abc import Callable
+from pathlib import Path
+
+from loguru import logger as log
+
+from src.config import MCPServerConfig
+
+from .parsers import ImportErrorDetails, parse_mcp_like_json, safe_read_json
+from .paths import (
+    find_claude_code_user_all_candidates,
+    find_claude_code_user_settings_file,
+    find_cursor_user_file,
+    find_vscode_user_mcp_file,
+)
+
+
+def import_from_cursor() -> list[MCPServerConfig]:
+    # Only support user-level Cursor config
+    files = find_cursor_user_file()
+    if not files:
+        raise ImportErrorDetails(
+            "Cursor MCP config not found (~/.cursor/mcp.json).",
+            Path.home() / ".cursor" / "mcp.json",
+        )
+    data = safe_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)
+
+
+def import_from_claude_code() -> list[MCPServerConfig]:
+    # Prefer Claude Code's documented user-level locations if present
+    files = find_claude_code_user_all_candidates()
+    if not files:
+        # Back-compat: also check specific settings.json location
+        files = find_claude_code_user_settings_file()
+    for f in files:
+        try:
+            log.info("Claude Code config detected at: {}", f)
+            data = safe_read_json(f)
+            parsed = parse_mcp_like_json(data, default_enabled=True)
+            if parsed:
+                return parsed
+        except Exception as e:
+            log.warning("Failed reading Claude Code config {}: {}", f, e)
+
+    # No user-level Claude Code config found; return empty per user preference
+    log.info("Claude Code config not found; returning empty result (no user-level config found)")
+    return []
+
+
+IMPORTERS: dict[str, Callable[..., list[MCPServerConfig]]] = {
+    "cursor": import_from_cursor,
+    "vscode": import_from_vscode,
+    "claude-code": import_from_claude_code,
+}

src/mcp_importer/merge.py

@@ -0,0 +1,47 @@
+from typing import Any
+
+from loguru import logger as log
+
+MCPServerConfigT = Any
+
+
+class MergePolicy:
+    SKIP = "skip"
+    OVERWRITE = "overwrite"
+    RENAME = "rename"
+
+
+def merge_servers(
+    existing: list[MCPServerConfigT],
+    imported: list[MCPServerConfigT],
+    policy: str,
+) -> list[MCPServerConfigT]:
+    name_to_index: dict[str, int] = {s.name: i for i, s in enumerate(existing)}
+    result: list[MCPServerConfigT] = list(existing)
+
+    for server in imported:
+        server.enabled = True
+        if server.name in name_to_index:
+            if policy == MergePolicy.SKIP:
+                log.info("Skipping duplicate server '{}' (policy=skip)", server.name)
+                continue
+            if policy == MergePolicy.OVERWRITE:
+                idx = name_to_index[server.name]
+                log.info("Overwriting server '{}' (policy=overwrite)", server.name)
+                result[idx] = server
+                continue
+            if policy == MergePolicy.RENAME:
+                suffix = "-imported"
+                base_name = server.name
+                counter = 1
+                new_name = f"{base_name}{suffix}"
+                while new_name in name_to_index:
+                    counter += 1
+                    new_name = f"{base_name}{suffix}-{counter}"
+                server.name = new_name
+                log.info(
+                    "Renamed imported server from '{}' to '{}' (policy=rename)", base_name, new_name
+                )
+        name_to_index[server.name] = len(result)
+        result.append(server)
+    return result

src/mcp_importer/parsers.py

@@ -0,0 +1,148 @@
+# pyright: reportUnknownArgumentType=false, reportUnknownVariableType=false, reportMissingImports=false, reportUnknownMemberType=false
+
+import json
+from pathlib import Path
+from typing import Any, cast
+
+from loguru import logger as log
+
+from src.config import MCPServerConfig
+
+
+# Import Open Edison types
+def _new_mcp_server_config(
+    *,
+    name: str,
+    command: str,
+    args: list[str],
+    env: dict[str, str] | None,
+    enabled: bool,
+    roots: list[str] | None,
+) -> Any:
+    """Runtime-constructed MCPServerConfig without static import coupling."""
+
+    return MCPServerConfig(
+        name=name,
+        command=command,
+        args=args,
+        env=env or {},
+        enabled=enabled,
+        roots=roots,
+    )
+
+
+class ImportErrorDetails(Exception):  # noqa: N818
+    def __init__(self, message: str, path: Path | None = None):
+        super().__init__(message)
+        self.path = path
+
+
+def safe_read_json(path: Path) -> dict[str, Any]:
+    try:
+        with open(path, encoding="utf-8") as f:
+            loaded = json.load(f)
+    except Exception as e:
+        raise ImportErrorDetails(f"Failed to read JSON from {path}: {e}", path) from e
+
+    if not isinstance(loaded, dict):
+        raise ImportErrorDetails(f"Expected JSON object at {path}", path)
+    data: dict[str, Any] = cast(dict[str, Any], loaded)
+    return data
+
+
+def _coerce_server_entry(name: str, node: dict[str, Any], default_enabled: bool) -> Any:
+    command_val = node.get("command", "")
+    command = str(command_val) if isinstance(command_val, str) else ""
+
+    args_raw = node.get("args", [])
+    if not isinstance(args_raw, list):
+        args_raw = []
+
+    # Some tools provide combined commandWithArgs
+    if command == "" and isinstance(node.get("commandWithArgs"), list):
+        cmd_with_args = [str(p) for p in node["commandWithArgs"]]
+        if cmd_with_args:
+            command = cmd_with_args[0]
+            args_raw = cmd_with_args[1:]
+
+    args: list[str] = [str(a) for a in args_raw]
+
+    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)
+
+    enabled = bool(node.get("enabled", default_enabled))
+
+    roots_raw = node.get("roots") or node.get("rootPaths") or []
+    roots: list[str] | None = None
+    if isinstance(roots_raw, list):
+        roots = [str(r) for r in roots_raw]
+        if len(roots) == 0:
+            roots = None
+
+    return _new_mcp_server_config(
+        name=name,
+        command=command,
+        args=args,
+        env=env,
+        enabled=enabled,
+        roots=roots,
+    )
+
+
+def _collect_from_dict(node_dict: dict[str, Any], default_enabled: bool) -> list[Any]:
+    results: list[Any] = []
+    for name_key, spec_obj in node_dict.items():
+        if isinstance(spec_obj, dict):
+            results.append(_coerce_server_entry(str(name_key), spec_obj, default_enabled))
+    return results
+
+
+def _collect_from_list(node_list: list[Any], default_enabled: bool) -> list[Any]:
+    results: list[Any] = []
+    for spec_obj in node_list:
+        if isinstance(spec_obj, dict) and "name" in spec_obj:
+            name_val_obj = spec_obj.get("name")
+            name_str = str(name_val_obj) if name_val_obj is not None else ""
+            results.append(_coerce_server_entry(name_str, spec_obj, default_enabled))
+    return results
+
+
+def _collect_top_level(data: dict[str, Any], default_enabled: bool) -> list[Any]:
+    results: list[Any] = []
+    for key in ("mcpServers", "servers"):
+        node = data.get(key)
+        if isinstance(node, dict):
+            results.extend(_collect_from_dict(node, default_enabled))
+        elif isinstance(node, list):
+            results.extend(_collect_from_list(node, default_enabled))
+    return results
+
+
+def _collect_nested(data: dict[str, Any], default_enabled: bool) -> list[Any]:
+    results: list[Any] = []
+    for _k, v in data.items():
+        # If nested dict, recurse regardless of key to catch structures like 'projects'
+        if isinstance(v, dict):
+            results.extend(parse_mcp_like_json(v, default_enabled=default_enabled))
+        # If nested list, recurse into dict items
+        elif isinstance(v, list):
+            for item in v:
+                if isinstance(item, dict):
+                    results.extend(parse_mcp_like_json(item, default_enabled=default_enabled))
+    return results
+
+
+def parse_mcp_like_json(data: dict[str, Any], default_enabled: bool = True) -> list[Any]:
+    # First, try top-level keys
+    top_level = _collect_top_level(data, default_enabled)
+    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