open-edison 0.1.34__py3-none-any.whl → 0.1.37__py3-none-any.whl

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

src/mcp_importer/paths.py

@@ -0,0 +1,92 @@
+import os
+import sys
+from pathlib import Path
+
+
+def is_windows() -> bool:
+    return os.name == "nt"
+
+
+def is_macos() -> bool:
+    return sys.platform == "darwin"
+
+
+def find_cursor_user_file() -> list[Path]:
+    """Find user-level Cursor MCP config (~/.cursor/mcp.json)."""
+    p = (Path.home() / ".cursor" / "mcp.json").resolve()
+    return [p] if p.exists() else []
+
+
+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 []
+
+
+def find_claude_code_user_settings_file() -> list[Path]:
+    """Find Claude Code user-level settings (~/.claude/settings.json)."""
+    p = (Path.home() / ".claude" / "settings.json").resolve()
+    return [p] if p.exists() else []
+
+
+def find_claude_code_user_all_candidates() -> list[Path]:
+    """Return ordered list of Claude Code user-level MCP config candidates.
+
+    Based on docs, check in priority order:
+      - ~/.claude.json (primary user-level)
+      - ~/.claude/settings.json
+      - ~/.claude/settings.local.json
+      - ~/.claude/mcp_servers.json
+    """
+    home = Path.home()
+    candidates: list[Path] = [
+        home / ".claude.json",
+        home / ".claude" / "settings.json",
+        home / ".claude" / "settings.local.json",
+        home / ".claude" / "mcp_servers.json",
+    ]
+    existing: list[Path] = []
+    for p in candidates:
+        rp = p.resolve()
+        if rp.exists():
+            existing.append(rp)
+    return existing
+
+
+# Shared utils for CLI import/export
+
+
+def detect_cursor_config_path() -> Path | None:
+    files = find_cursor_user_file()
+    return files[0] if files else None
+
+
+def detect_vscode_config_path() -> Path | None:
+    files = find_vscode_user_mcp_file()
+    return files[0] if files else 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()
+
+
+def get_default_cursor_config_path() -> Path:
+    return (Path.home() / ".cursor" / "mcp.json").resolve()
+
+
+def detect_claude_code_config_path() -> Path | None:
+    candidates = find_claude_code_user_all_candidates()
+    return candidates[0] if candidates else None
+
+
+def get_default_claude_code_config_path() -> Path:
+    # Prefer top-level ~/.claude.json as default create target
+    return (Path.home() / ".claude.json").resolve()

src/mcp_importer/quick_cli.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import argparse
+from collections.abc import Iterable
+
+from mcp_importer.api import (
+    CLIENT,
+    detect_clients,
+    export_edison_to,
+    import_from,
+    save_imported_servers,
+)
+
+
+def _pick_first(iterable: Iterable[CLIENT]) -> CLIENT | None:
+    for item in iterable:
+        return item
+    return None
+
+
+def run_cli(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Detect a client, import its servers into Open Edison, and export Open Edison back to it."
+        )
+    )
+    parser.add_argument("--dry-run", action="store_true", help="Preview actions without writing")
+    parser.add_argument("--yes", action="store_true", help="Skip confirmations (no effect here)")
+    args = parser.parse_args(argv)
+
+    detected = detect_clients()
+    client = _pick_first(detected)
+    if client is None:
+        print("No supported clients detected.")
+        return 2
+
+    servers = import_from(client)
+    if not servers:
+        print(f"No servers found to import from '{client.value}'.")
+        return 0
+
+    if args.dry_run:
+        print(
+            f"[dry-run] Would import {len(servers)} server(s) from '{client.value}' and save to config.json"
+        )
+        # Exercise export path safely (no writes)
+        export_edison_to(client, dry_run=True, force=True, create_if_missing=True)
+        print(
+            f"[dry-run] Would export Open Edison to '{client.value}' (backup and replace editor MCP config)"
+        )
+        print("Dry-run complete.")
+        return 0
+
+    save_imported_servers(servers)
+    export_edison_to(client, dry_run=False, force=True, create_if_missing=True)
+    print(f"Completed quick import/export for {client.value}.")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    return run_cli(argv)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/mcp_importer/types.py

@@ -0,0 +1,5 @@
+"""Type helpers for MCP importer."""
+
+from __future__ import annotations
+
+# This module intentionally minimal to avoid unused code flags.

src/server.py

@@ -30,7 +30,7 @@ from loguru import logger as log
 from pydantic import BaseModel, Field
 
 from src import events
-from src.config import Config, MCPServerConfig, load_json_file
+from src.config import Config, MCPServerConfig, clear_json_file_cache
 from src.config import get_config_dir as _get_cfg_dir  # type: ignore[attr-defined]
 from src.middleware.session_tracking import (
     MCPSessionModel,
@@ -275,7 +275,7 @@ class OpenEdisonProxy:
 
                 # Clear cache for the config file, if it was config.json
                 if name == "config.json":
-                    load_json_file.cache_clear()
+                    clear_json_file_cache()
 
                 return {"status": "ok"}
             except Exception as e:  # noqa: BLE001

open_edison-0.1.34.dist-info/RECORD

@@ -1,21 +0,0 @@
-src/__init__.py,sha256=QWeZdjAm2D2B0eWhd8m2-DPpWvIP26KcNJxwEoU1oEQ,254
-src/__main__.py,sha256=kQsaVyzRa_ESC57JpKDSQJAHExuXme0rM5beJsYxFeA,161
-src/cli.py,sha256=Mz8nMlCHJk0Il8Kr6wB5iKPPMb3WpbBfU2PPLsnYicE,10235
-src/config.py,sha256=CHrKta7WZbwhKy7FK9y1FEmhbg6VyI5mXhRJ0GHGM6s,10130
-src/events.py,sha256=rBH7rnaSWZ7GIC8zyBTwpcvIKWmKYCki-DNGgJhxPow,5001
-src/oauth_manager.py,sha256=qcQa5BDRZr4bjqiXNflCnrXOh9mo9JVjvP2Caseg2Uc,9943
-src/permissions.py,sha256=NGAnlG_z59HEiVA-k3cYvwmmiuHzxuNb5Tbd5umbL00,10483
-src/server.py,sha256=DLs-ak35cyEDROctDjzI6-C_ymWe3RekETW0XA5ag_M,45650
-src/single_user_mcp.py,sha256=rJrlqHcIubGkos_24ux5rb3OoKYDzvagCHghhfDeXTI,18535
-src/telemetry.py,sha256=-RZPIjpI53zbsKmp-63REeZ1JirWHV5WvpSRa2nqZEk,11321
-src/frontend_dist/index.html,sha256=s95FMkH8VLisvawLH7bZxbLzRUFvMhHkH6ZMzpVBngs,673
-src/frontend_dist/sw.js,sha256=rihX1es-vWwjmtnXyaksJjs2dio6MVAOTAWwQPeJUYw,2164
-src/frontend_dist/assets/index-BUUcUfTt.js,sha256=awoyPI6u0v6ao2iarZdSkrSDUvyU8aNkMLqHMvgVgyY,257666
-src/frontend_dist/assets/index-o6_8mdM8.css,sha256=nwmX_6q55mB9463XN2JM8BdeihjkALpQK83Fc3_iGvE,15936
-src/middleware/data_access_tracker.py,sha256=bArBffWgYmvxOx9z_pgXQhogvnWQcc1m6WvEblDD4gw,15039
-src/middleware/session_tracking.py,sha256=5W1VH9HNqIZeX0HNxDEm41U4GY6SqKSXtApDEeZK2qo,23084
-open_edison-0.1.34.dist-info/METADATA,sha256=UkIWgEvTC1MzzM9xu2sTg4Ik2MVoG99pAE5W2UOa1d4,12077
-open_edison-0.1.34.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_edison-0.1.34.dist-info/entry_points.txt,sha256=qNAkJcnoTXRhj8J--3PDmXz_TQKdB8H_0C9wiCtDIyA,72
-open_edison-0.1.34.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-open_edison-0.1.34.dist-info/RECORD,,

open_edison-0.1.34.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-open-edison = src.cli:main
-open_edison = src.cli:main