mcpswitch-cli 0.1.0__py3-none-any.whl

mcpswitch/hooks.py

@@ -0,0 +1,269 @@
+"""Claude Code hook handlers.
+
+Hooks receive JSON on stdin, write response to stdout.
+
+PreToolUse  — fires before every tool call
+              → check if MCP is loaded, warn if not
+PostToolUse — fires after every tool call
+              → log the call to usage.db (data moat)
+
+Install with: mcpswitch setup
+"""
+
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+from .usage import log_tool_call, _extract_server
+from .profiles import get_active_profile, load_profiles
+from .config import get_claude_code_config_path, get_all_mcp_servers
+
+
+def _read_stdin() -> Optional[dict]:
+    try:
+        raw = sys.stdin.read()
+        return json.loads(raw) if raw.strip() else None
+    except Exception:
+        return None
+
+
+def _write_response(data: dict) -> None:
+    sys.stdout.write(json.dumps(data) + "\n")
+    sys.stdout.flush()
+
+
+def handle_post_tool_use() -> None:
+    """PostToolUse hook — log every MCP tool call.
+
+    stdin JSON:
+    {
+      "session_id": "abc123",
+      "tool_name": "mcp__github__create_pull_request",
+      "tool_input": {...},
+      "tool_result": {...}
+    }
+    """
+    data = _read_stdin()
+    if not data:
+        sys.exit(0)
+
+    tool_name = data.get("tool_name", "")
+    server = _extract_server(tool_name)
+
+    if not server:
+        sys.exit(0)  # Not an MCP tool, skip
+
+    session_id = data.get("session_id")
+    project_dir = os.getcwd()
+    active_profile = get_active_profile()
+
+    # Determine success from tool result
+    result = data.get("tool_result", {})
+    success = True
+    if isinstance(result, dict):
+        success = not result.get("isError", False)
+
+    log_tool_call(
+        tool_name=tool_name,
+        session_id=session_id,
+        profile_name=active_profile,
+        project_dir=project_dir,
+        success=success,
+    )
+
+    sys.exit(0)
+
+
+def handle_pre_tool_use() -> None:
+    """PreToolUse hook — check if MCP is loaded, warn user if not.
+
+    Does NOT block the tool call (exit 0 always).
+    Just warns the user so they know to switch profile next session.
+
+    stdin JSON:
+    {
+      "session_id": "abc123",
+      "tool_name": "mcp__github__create_pull_request",
+      "tool_input": {...}
+    }
+
+    Output (if warning):
+    {
+      "hookSpecificOutput": {
+        "permissionDecision": "allow",
+        "userFacingMessage": "MCPSwitch: github not in active profile 'lean'. Run: mcpswitch use full"
+      }
+    }
+    """
+    data = _read_stdin()
+    if not data:
+        sys.exit(0)
+
+    tool_name = data.get("tool_name", "")
+    server = _extract_server(tool_name)
+
+    if not server:
+        sys.exit(0)
+
+    # Check if this server is in the current Claude config
+    try:
+        config_path = get_claude_code_config_path()
+        loaded_servers = get_all_mcp_servers(config_path)
+        active_profile = get_active_profile()
+
+        if server not in loaded_servers:
+            # Find which profiles have this server
+            all_profiles = load_profiles()
+            profiles_with_server = [
+                name for name, servers in all_profiles.items()
+                if server in servers
+            ]
+
+            if profiles_with_server:
+                suggestion = f"mcpswitch use {profiles_with_server[0]}"
+            else:
+                suggestion = f"mcpswitch add <profile> {server}"
+
+            msg = (
+                f"[MCPSwitch] '{server}' not in active profile '{active_profile or 'none'}'. "
+                f"Tool may fail. Fix: {suggestion}"
+            )
+            _write_response({
+                "hookSpecificOutput": {
+                    "permissionDecision": "allow",
+                    "userFacingMessage": msg,
+                }
+            })
+    except Exception:
+        pass
+
+    sys.exit(0)
+
+
+def get_hooks_config() -> dict:
+    """Return the hooks config block to inject into ~/.claude/settings.json.
+
+    Uses the mcpswitch module directly so no path issues.
+    Python executable from current venv or system python.
+    """
+    python = sys.executable
+
+    return {
+        "PreToolUse": [
+            {
+                "matcher": "mcp__.*",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": f'"{python}" -m mcpswitch.hooks pre_tool_use',
+                    }
+                ],
+            }
+        ],
+        "PostToolUse": [
+            {
+                "matcher": "mcp__.*",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": f'"{python}" -m mcpswitch.hooks post_tool_use',
+                    }
+                ],
+            }
+        ],
+    }
+
+
+def install_hooks(dry_run: bool = False) -> dict:
+    """Install MCPSwitch hooks into ~/.claude/settings.json.
+
+    Returns {"added": [...], "already_existed": [...], "settings_path": str}
+    """
+    import json as _json
+    settings_path = Path.home() / ".claude" / "settings.json"
+    settings_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if settings_path.exists():
+        with open(settings_path, "r", encoding="utf-8") as f:
+            settings = _json.load(f)
+    else:
+        settings = {}
+
+    existing_hooks = settings.get("hooks", {})
+    new_hooks = get_hooks_config()
+
+    added = []
+    already_existed = []
+
+    for hook_type, hook_list in new_hooks.items():
+        existing = existing_hooks.get(hook_type, [])
+        # Check if mcpswitch hook already present
+        already = any("mcpswitch" in str(h) for h in existing)
+        if already:
+            already_existed.append(hook_type)
+        else:
+            if not dry_run:
+                existing_hooks[hook_type] = existing + hook_list
+            added.append(hook_type)
+
+    if not dry_run and added:
+        settings["hooks"] = existing_hooks
+        # Backup first
+        if settings_path.exists():
+            backup = settings_path.with_suffix(".json.bak")
+            import shutil
+            shutil.copy2(settings_path, backup)
+        with open(settings_path, "w", encoding="utf-8") as f:
+            _json.dump(settings, f, indent=2)
+
+    return {
+        "added": added,
+        "already_existed": already_existed,
+        "settings_path": str(settings_path),
+    }
+
+
+def uninstall_hooks() -> dict:
+    """Remove MCPSwitch hooks from ~/.claude/settings.json."""
+    import json as _json
+    settings_path = Path.home() / ".claude" / "settings.json"
+
+    if not settings_path.exists():
+        return {"removed": [], "settings_path": str(settings_path)}
+
+    with open(settings_path, "r", encoding="utf-8") as f:
+        settings = _json.load(f)
+
+    hooks = settings.get("hooks", {})
+    removed = []
+
+    for hook_type in list(hooks.keys()):
+        original_count = len(hooks[hook_type])
+        hooks[hook_type] = [
+            h for h in hooks[hook_type]
+            if "mcpswitch" not in str(h)
+        ]
+        if len(hooks[hook_type]) < original_count:
+            removed.append(hook_type)
+        if not hooks[hook_type]:
+            del hooks[hook_type]
+
+    settings["hooks"] = hooks
+    with open(settings_path, "w", encoding="utf-8") as f:
+        _json.dump(settings, f, indent=2)
+
+    return {"removed": removed, "settings_path": str(settings_path)}
+
+
+# Entry point when run as: python -m mcpswitch.hooks <command>
+if __name__ == "__main__":
+    cmd = sys.argv[1] if len(sys.argv) > 1 else ""
+    if cmd == "pre_tool_use":
+        handle_pre_tool_use()
+    elif cmd == "post_tool_use":
+        handle_post_tool_use()
+    else:
+        sys.exit(0)

mcpswitch/profiles.py

@@ -0,0 +1,96 @@
+"""Profile management — create, read, update, delete MCP profiles."""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+PROFILES_DIR = Path.home() / ".mcpswitch"
+PROFILES_FILE = PROFILES_DIR / "profiles.json"
+STATE_FILE = PROFILES_DIR / "state.json"
+
+
+def _ensure_dir():
+    PROFILES_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_profiles() -> dict:
+    """Load all profiles from disk."""
+    _ensure_dir()
+    if not PROFILES_FILE.exists():
+        return {}
+    with open(PROFILES_FILE, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def save_profiles(profiles: dict) -> None:
+    """Save all profiles to disk."""
+    _ensure_dir()
+    with open(PROFILES_FILE, "w", encoding="utf-8") as f:
+        json.dump(profiles, f, indent=2)
+
+
+def get_active_profile() -> Optional[str]:
+    """Return name of currently active profile."""
+    _ensure_dir()
+    if not STATE_FILE.exists():
+        return None
+    with open(STATE_FILE, "r", encoding="utf-8") as f:
+        return json.load(f).get("active")
+
+
+def set_active_profile(name: Optional[str]) -> None:
+    """Set the active profile name."""
+    _ensure_dir()
+    with open(STATE_FILE, "w", encoding="utf-8") as f:
+        json.dump({"active": name}, f, indent=2)
+
+
+def create_profile(name: str, servers: dict) -> None:
+    """Create or overwrite a profile with the given servers."""
+    profiles = load_profiles()
+    profiles[name] = servers
+    save_profiles(profiles)
+
+
+def get_profile(name: str) -> Optional[dict]:
+    """Get servers dict for a profile."""
+    return load_profiles().get(name)
+
+
+def delete_profile(name: str) -> bool:
+    """Delete a profile. Returns False if not found."""
+    profiles = load_profiles()
+    if name not in profiles:
+        return False
+    del profiles[name]
+    save_profiles(profiles)
+    if get_active_profile() == name:
+        set_active_profile(None)
+    return True
+
+
+def list_profiles() -> list[str]:
+    """Return sorted list of profile names."""
+    return sorted(load_profiles().keys())
+
+
+def add_server_to_profile(profile_name: str, server_name: str, server_config: dict) -> bool:
+    """Add a server to an existing profile. Returns False if profile not found."""
+    profiles = load_profiles()
+    if profile_name not in profiles:
+        return False
+    profiles[profile_name][server_name] = server_config
+    save_profiles(profiles)
+    return True
+
+
+def remove_server_from_profile(profile_name: str, server_name: str) -> bool:
+    """Remove a server from a profile. Returns False if not found."""
+    profiles = load_profiles()
+    if profile_name not in profiles:
+        return False
+    if server_name not in profiles[profile_name]:
+        return False
+    del profiles[profile_name][server_name]
+    save_profiles(profiles)
+    return True

mcpswitch/sync.py

@@ -0,0 +1,237 @@
+"""Multi-machine profile sync via GitHub Gists.
+
+No backend server needed. Each user gets a private Gist as their sync target.
+
+Pro feature:
+  mcpswitch sync --setup <github-token>   → create private Gist, store token
+  mcpswitch sync --push                   → upload local profiles to Gist
+  mcpswitch sync --pull                   → download profiles from Gist
+  mcpswitch sync --status                 → show sync state
+
+GitHub token needs: gist scope only (minimal permissions).
+Create at: https://github.com/settings/tokens/new?scopes=gist
+"""
+
+import json
+import time
+import urllib.request
+import urllib.error
+from pathlib import Path
+from typing import Optional
+
+SYNC_CONFIG_FILE = Path.home() / ".mcpswitch" / "sync.json"
+GIST_API = "https://api.github.com/gists"
+GIST_FILENAME = "mcpswitch-profiles.json"
+
+
+def _load_sync_config() -> dict:
+    if not SYNC_CONFIG_FILE.exists():
+        return {}
+    try:
+        with open(SYNC_CONFIG_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def _save_sync_config(data: dict) -> None:
+    SYNC_CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    with open(SYNC_CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+
+
+def _github_request(
+    url: str,
+    method: str = "GET",
+    token: str = "",
+    payload: Optional[dict] = None,
+) -> Optional[dict]:
+    try:
+        data = json.dumps(payload).encode("utf-8") if payload else None
+        req = urllib.request.Request(
+            url,
+            data=data,
+            method=method,
+            headers={
+                "Authorization": f"token {token}",
+                "Accept": "application/vnd.github.v3+json",
+                "Content-Type": "application/json",
+                "User-Agent": "mcpswitch/0.1",
+            },
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            return json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", errors="ignore")
+        return {"error": e.code, "message": body}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def setup_sync(github_token: str) -> dict:
+    """Create a private Gist and store the token for future syncs."""
+    from .profiles import load_profiles
+
+    profiles = load_profiles()
+    payload = {
+        "description": "MCPSwitch profile sync",
+        "public": False,
+        "files": {
+            GIST_FILENAME: {
+                "content": json.dumps({
+                    "version": 1,
+                    "profiles": profiles,
+                    "synced_at": time.time(),
+                    "machine": _get_machine_id(),
+                }, indent=2)
+            }
+        }
+    }
+
+    result = _github_request(GIST_API, method="POST", token=github_token, payload=payload)
+
+    if not result or "error" in result:
+        return {"success": False, "message": f"Failed to create Gist: {result}"}
+
+    gist_id = result.get("id")
+    gist_url = result.get("html_url")
+
+    _save_sync_config({
+        "github_token": github_token,
+        "gist_id": gist_id,
+        "gist_url": gist_url,
+        "last_push": time.time(),
+        "last_pull": None,
+    })
+
+    return {
+        "success": True,
+        "gist_id": gist_id,
+        "gist_url": gist_url,
+        "message": f"Sync configured. Gist: {gist_url}",
+    }
+
+
+def push_profiles() -> dict:
+    """Upload local profiles to the sync Gist."""
+    config = _load_sync_config()
+    if not config.get("gist_id"):
+        return {"success": False, "message": "Sync not configured. Run: mcpswitch sync --setup"}
+
+    from .profiles import load_profiles
+    profiles = load_profiles()
+
+    payload = {
+        "files": {
+            GIST_FILENAME: {
+                "content": json.dumps({
+                    "version": 1,
+                    "profiles": profiles,
+                    "synced_at": time.time(),
+                    "machine": _get_machine_id(),
+                }, indent=2)
+            }
+        }
+    }
+
+    url = f"{GIST_API}/{config['gist_id']}"
+    result = _github_request(url, method="PATCH", token=config["github_token"], payload=payload)
+
+    if not result or "error" in result:
+        return {"success": False, "message": f"Push failed: {result}"}
+
+    config["last_push"] = time.time()
+    _save_sync_config(config)
+
+    return {
+        "success": True,
+        "profiles_pushed": len(profiles),
+        "message": f"Pushed {len(profiles)} profile(s) to Gist.",
+    }
+
+
+def pull_profiles(merge: bool = True) -> dict:
+    """Download profiles from the sync Gist.
+
+    If merge=True: remote profiles are merged with local (remote wins on conflict).
+    If merge=False: remote profiles completely replace local.
+    """
+    config = _load_sync_config()
+    if not config.get("gist_id"):
+        return {"success": False, "message": "Sync not configured. Run: mcpswitch sync --setup"}
+
+    url = f"{GIST_API}/{config['gist_id']}"
+    result = _github_request(url, token=config["github_token"])
+
+    if not result or "error" in result:
+        return {"success": False, "message": f"Pull failed: {result}"}
+
+    try:
+        content = result["files"][GIST_FILENAME]["content"]
+        remote_data = json.loads(content)
+        remote_profiles = remote_data.get("profiles", {})
+    except (KeyError, json.JSONDecodeError) as e:
+        return {"success": False, "message": f"Invalid Gist format: {e}"}
+
+    from .profiles import load_profiles, save_profiles
+    local_profiles = load_profiles()
+
+    if merge:
+        merged = {**local_profiles, **remote_profiles}
+    else:
+        merged = remote_profiles
+
+    save_profiles(merged)
+
+    config["last_pull"] = time.time()
+    _save_sync_config(config)
+
+    new_count = len(set(remote_profiles) - set(local_profiles))
+    updated_count = len(set(remote_profiles) & set(local_profiles))
+
+    return {
+        "success": True,
+        "new_profiles": new_count,
+        "updated_profiles": updated_count,
+        "total_profiles": len(merged),
+        "message": f"Pulled: {new_count} new, {updated_count} updated. Total: {len(merged)} profiles.",
+    }
+
+
+def get_sync_status() -> dict:
+    """Return current sync configuration and status."""
+    config = _load_sync_config()
+    if not config.get("gist_id"):
+        return {"configured": False}
+
+    last_push = config.get("last_push")
+    last_pull = config.get("last_pull")
+
+    return {
+        "configured": True,
+        "gist_url": config.get("gist_url"),
+        "gist_id": config.get("gist_id"),
+        "last_push": last_push,
+        "last_push_ago": _ago(last_push),
+        "last_pull": last_pull,
+        "last_pull_ago": _ago(last_pull),
+    }
+
+
+def _ago(ts: Optional[float]) -> str:
+    if not ts:
+        return "never"
+    diff = time.time() - ts
+    if diff < 60:
+        return f"{int(diff)}s ago"
+    if diff < 3600:
+        return f"{int(diff/60)}m ago"
+    if diff < 86400:
+        return f"{int(diff/3600)}h ago"
+    return f"{int(diff/86400)}d ago"
+
+
+def _get_machine_id() -> str:
+    import socket
+    import platform
+    return f"{socket.gethostname()}-{platform.system()}"