second-opinion-mcp 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

second_opinion_mcp/__init__.py

@@ -1,6 +1,6 @@
 """Second Opinion MCP Server - Multi-model AI analysis for Claude."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"
 __author__ = "MarvinFS"
 
 from second_opinion_mcp.server import mcp, second_opinion, challenge, code_review, consensus, review_synthesis

second_opinion_mcp/cli.py

@@ -11,6 +11,7 @@ except ImportError:
     sys.exit(1)
 
 import keyring
+from keyring.errors import NoKeyringError
 
 # Provider configurations
 PROVIDERS = {
@@ -19,7 +20,7 @@ PROVIDERS = {
         "description": "DeepSeek Reasoner with chain-of-thought reasoning",
         "keyring_service": "second-opinion",
         "keyring_name": "deepseek",
-        "key_hint": "Get your key at https://platform.deepseek.com",
+        "key_hint": "https://platform.deepseek.com",
         "key_prefix": "sk-",
     },
     "moonshot": {
@@ -27,7 +28,7 @@ PROVIDERS = {
         "description": "Moonshot AI's Kimi with thinking mode",
         "keyring_service": "second-opinion",
         "keyring_name": "moonshot",
-        "key_hint": "Get your key at https://platform.moonshot.cn",
+        "key_hint": "https://platform.moonshot.cn",
         "key_prefix": None,
     },
     "openrouter": {
@@ -35,7 +36,7 @@ PROVIDERS = {
         "description": "Access 300+ models via unified API",
         "keyring_service": "second-opinion",
         "keyring_name": "openrouter",
-        "key_hint": "Get your key at https://openrouter.ai/keys",
+        "key_hint": "https://openrouter.ai/keys",
         "key_prefix": "sk-or-",
     },
 }
@@ -51,6 +52,122 @@ custom_style = Style([
 ])
 
 
+def check_keyring_available() -> tuple[bool, str]:
+    """Check if keyring backend is available and working."""
+    try:
+        # Try to access keyring - this will fail if no backend
+        backend = keyring.get_keyring()
+        backend_name = str(type(backend).__name__)
+
+        # Check for null/fail backends
+        if "Null" in backend_name or "Fail" in backend_name:
+            return False, backend_name
+
+        # Try a test write/read/delete to verify it works
+        test_service = "second-opinion-test"
+        test_key = "connectivity-check"
+        try:
+            keyring.set_password(test_service, test_key, "test")
+            result = keyring.get_password(test_service, test_key)
+            keyring.delete_password(test_service, test_key)
+            if result != "test":
+                return False, backend_name
+        except Exception:
+            return False, backend_name
+
+        return True, backend_name
+    except NoKeyringError:
+        return False, "NoKeyringError"
+    except Exception as e:
+        return False, str(e)
+
+
+def print_keyring_setup_instructions():
+    """Print instructions for setting up keyring on different platforms."""
+    print()
+    print("=" * 60)
+    print("  Keyring Backend Required")
+    print("=" * 60)
+    print()
+    print("second-opinion-mcp stores API keys securely in your system keyring.")
+    print("A keyring backend must be installed and configured first.")
+    print()
+
+    system = platform.system()
+
+    if system == "Linux":
+        print("For Linux, install one of these backends:")
+        print()
+        print("  Option 1 - Secret Service (GNOME/KDE desktop):")
+        print("    sudo apt install gnome-keyring  # or kde-wallet")
+        print("    pip install secretstorage")
+        print()
+        print("  Option 2 - Encrypted file (headless/server):")
+        print("    pip install keyrings.alt")
+        print("    mkdir -p ~/.local/share/python_keyring")
+        print("    cat > ~/.local/share/python_keyring/keyringrc.cfg << 'EOF'")
+        print("    [backend]")
+        print("    default-keyring=keyrings.alt.file.EncryptedKeyring")
+        print("    EOF")
+        print()
+        print("  Then run 'second-opinion-mcp setup' again.")
+
+    elif system == "Darwin":
+        print("For macOS, keyring should work automatically with Keychain.")
+        print("If you see this error, try:")
+        print()
+        print("  pip install keyring --upgrade")
+        print()
+        print("Then run 'second-opinion-mcp setup' again.")
+
+    else:
+        print("For Windows, keyring should work automatically with Credential Manager.")
+        print("If you see this error, try:")
+        print()
+        print("  pip install keyring --upgrade")
+        print()
+        print("Then run 'second-opinion-mcp setup' again.")
+
+    print()
+
+
+def print_manual_setup_instructions(providers: list[str] | None = None):
+    """Print instructions for manual keyring setup."""
+    print()
+    print("=" * 60)
+    print("  Manual API Key Setup")
+    print("=" * 60)
+    print()
+    print("IMPORTANT: You must configure at least 2 providers for the")
+    print("'consensus' tool to work. Single-provider mode is limited.")
+    print()
+    print("Run these commands to store your API keys:")
+    print()
+
+    target_providers = providers if providers else list(PROVIDERS.keys())
+
+    for provider in target_providers:
+        config = PROVIDERS[provider]
+        print(f"  # {config['name']} - Get key at {config['key_hint']}")
+        print(f"  python -c \"import keyring; keyring.set_password('{config['keyring_service']}', '{config['keyring_name']}', 'YOUR_API_KEY')\"")
+        print()
+
+    print("To verify your keys are stored:")
+    print()
+    print("  python -c \"import keyring; print('deepseek:', bool(keyring.get_password('second-opinion', 'deepseek'))); print('moonshot:', bool(keyring.get_password('second-opinion', 'moonshot')))\"")
+    print()
+    print("After configuring keys, register with Claude Code:")
+    print()
+
+    if providers and len(providers) >= 1:
+        providers_str = ",".join(providers)
+    else:
+        providers_str = "deepseek,moonshot"
+
+    print(f"  claude mcp add -s user second-opinion -e SECOND_OPINION_PROVIDERS=\"{providers_str}\" -- second-opinion-mcp")
+    print()
+
+
 def check_existing_keys() -> dict[str, bool]:
     """Check which providers already have API keys configured."""
     existing = {}
@@ -63,15 +180,19 @@ def check_existing_keys() -> dict[str, bool]:
     return existing
 
 
-def store_api_key(provider: str, key: str) -> bool:
-    """Store API key in system keyring."""
+def count_configured_providers() -> int:
+    """Count how many providers have API keys configured."""
+    return sum(1 for v in check_existing_keys().values() if v)
+
+
+def store_api_key(provider: str, key: str) -> tuple[bool, str]:
+    """Store API key in system keyring. Returns (success, error_message)."""
     config = PROVIDERS[provider]
     try:
         keyring.set_password(config["keyring_service"], config["keyring_name"], key)
-        return True
+        return True, ""
     except Exception as e:
-        print(f"Error storing key: {e}")
-        return False
+        return False, str(e)
 
 
 def validate_api_key(provider: str, key: str) -> tuple[bool, str]:
@@ -94,11 +215,7 @@ def validate_api_key(provider: str, key: str) -> tuple[bool, str]:
 def get_registration_command(selected_providers: list[str]) -> str:
     """Generate the registration command for Claude Code CLI."""
     providers_env = ",".join(selected_providers)
-
-    if platform.system() == "Windows":
-        return f'''claude mcp add -s user second-opinion -e SECOND_OPINION_PROVIDERS="{providers_env}" -- second-opinion-mcp'''
-    else:
-        return f'''claude mcp add -s user second-opinion -e SECOND_OPINION_PROVIDERS="{providers_env}" -- second-opinion-mcp'''
+    return f'claude mcp add -s user second-opinion -e SECOND_OPINION_PROVIDERS="{providers_env}" -- second-opinion-mcp'
 
 
 def get_desktop_config(selected_providers: list[str]) -> str:
@@ -124,29 +241,92 @@ def setup_wizard():
     print("  Second Opinion MCP - Setup Wizard")
     print("=" * 60)
     print()
+
+    # Check keyring availability first
+    keyring_ok, backend_info = check_keyring_available()
+
+    if not keyring_ok:
+        print(f"Keyring backend not available: {backend_info}")
+        print_keyring_setup_instructions()
+        print()
+        print("Alternatively, choose 'Manual setup' to get CLI commands.")
+        print()
+
+        choice = questionary.select(
+            "How would you like to proceed?",
+            choices=[
+                questionary.Choice("Manual setup (show CLI commands)", value="manual"),
+                questionary.Choice("Exit and fix keyring first", value="exit"),
+            ],
+            style=custom_style,
+        ).ask()
+
+        if choice == "manual" or choice is None:
+            print_manual_setup_instructions()
+        return
+
     print("This wizard will help you configure API keys for AI providers.")
     print("Keys are stored securely in your system keyring.")
     print()
 
     # Check existing configuration
     existing = check_existing_keys()
-    has_existing = any(existing.values())
+    configured_count = sum(1 for v in existing.values() if v)
 
-    if has_existing:
+    if configured_count > 0:
         configured = [p for p, has_key in existing.items() if has_key]
         print(f"Already configured: {', '.join(configured)}")
+        if configured_count < 2:
+            print("Note: At least 2 providers required for 'consensus' tool.")
         print()
 
-    # Provider selection
+    # Setup method selection
+    setup_method = questionary.select(
+        "Setup method:",
+        choices=[
+            questionary.Choice("Interactive (enter keys now)", value="interactive"),
+            questionary.Choice("Manual (show CLI commands)", value="manual"),
+        ],
+        style=custom_style,
+    ).ask()
+
+    if setup_method is None:
+        print("Setup cancelled.")
+        return
+
+    if setup_method == "manual":
+        # Ask which providers they want to configure
+        choices = [
+            questionary.Choice(
+                f"{config['name']}" + (" (configured)" if existing.get(provider) else ""),
+                value=provider,
+                checked=not existing.get(provider)  # Pre-check unconfigured ones
+            )
+            for provider, config in PROVIDERS.items()
+        ]
+
+        selected = questionary.checkbox(
+            "Select providers to configure:",
+            choices=choices,
+            style=custom_style,
+        ).ask()
+
+        if not selected:
+            selected = list(PROVIDERS.keys())
+
+        print_manual_setup_instructions(selected)
+        return
+
+    # Interactive setup
     choices = []
     for provider, config in PROVIDERS.items():
         label = config["name"]
         if existing.get(provider):
             label += " (configured)"
-        choices.append(questionary.Choice(label, value=provider, checked=existing.get(provider, False)))
+        choices.append(questionary.Choice(label, value=provider, checked=not existing.get(provider)))
 
     selected = questionary.checkbox(
-        "Select providers to configure (at least 2 recommended):",
+        "Select providers to configure (at least 2 required for consensus):",
         choices=choices,
         style=custom_style,
         validate=lambda x: len(x) >= 1 or "Select at least one provider",
@@ -156,20 +336,24 @@ def setup_wizard():
         print("Setup cancelled.")
         return
 
-    if len(selected) < 2:
+    # Warn about single provider
+    total_will_have = len([p for p in selected if not existing.get(p)]) + configured_count
+    if total_will_have < 2 and len(selected) < 2:
         print()
-        print("Note: Using 2+ providers enables the 'consensus' tool for multi-model debates.")
+        print("WARNING: You need at least 2 providers for the 'consensus' tool.")
+        print("With only 1 provider, only basic tools will be available.")
         proceed = questionary.confirm(
-            "Continue with single provider?",
-            default=True,
+            "Continue anyway?",
+            default=False,
             style=custom_style,
         ).ask()
         if not proceed:
-            return setup_wizard()  # Restart
+            return setup_wizard()
 
     print()
 
     # Configure API keys
+    keyring_error_shown = False
     for provider in selected:
         config = PROVIDERS[provider]
 
@@ -183,15 +367,15 @@ def setup_wizard():
                 continue
 
         print(f"\n{config['name']}")
-        print(f"  {config['key_hint']}")
+        print(f"  Get your key at: {config['key_hint']}")
 
         while True:
             key = questionary.password(
-                f"  Enter API key:",
+                "  Enter API key:",
                 style=custom_style,
             ).ask()
 
-            if key is None:  # User cancelled
+            if key is None:
                 print("  Skipped.")
                 break
 
@@ -203,44 +387,55 @@ def setup_wizard():
                     break
                 continue
 
-            if store_api_key(provider, key.strip()):
+            success, store_error = store_api_key(provider, key.strip())
+            if success:
                 print("  Key stored successfully.")
-            break
+                break
+            else:
+                print(f"  Error storing key: {store_error}")
+                if not keyring_error_shown:
+                    keyring_error_shown = True
+                    print()
+                    print("  Keyring storage failed. You may need to configure a backend.")
+                    show_manual = questionary.confirm(
+                        "  Show manual setup instructions?",
+                        default=True,
+                        style=custom_style,
+                    ).ask()
+                    if show_manual:
+                        print_manual_setup_instructions(selected)
+                        return
+                break
+
+    # Check final configuration
+    final_existing = check_existing_keys()
+    configured = [p for p, has_key in final_existing.items() if has_key]
 
-    # Generate registration commands
     print()
     print("=" * 60)
     print("  Setup Complete!")
     print("=" * 60)
     print()
 
-    # Filter to providers that now have keys
-    configured = []
-    for provider in selected:
-        try:
-            key = keyring.get_password(
-                PROVIDERS[provider]["keyring_service"],
-                PROVIDERS[provider]["keyring_name"]
-            )
-            if key:
-                configured.append(provider)
-        except Exception:
-            pass
-
     if not configured:
-        print("No API keys were configured. Run 'second-opinion-mcp setup' to try again.")
+        print("No API keys were configured.")
+        print("Run 'second-opinion-mcp setup' to try again.")
         return
 
     print(f"Configured providers: {', '.join(configured)}")
-    print()
 
-    # Show registration command
-    print("For Claude Code CLI, run:")
+    if len(configured) < 2:
+        print()
+        print("WARNING: Only 1 provider configured. The 'consensus' tool requires 2+.")
+        print("Run 'second-opinion-mcp setup' to add more providers.")
+
+    print()
+    print("Register with Claude Code CLI:")
     print()
     print(f"  {get_registration_command(configured)}")
     print()
 
-    # Show desktop config
+    # Show desktop config option
     show_desktop = questionary.confirm(
         "Show Claude Desktop configuration?",
         default=False,
@@ -264,8 +459,6 @@ def setup_wizard():
     print("Test the server with:")
     print("  second-opinion-mcp")
     print()
-    print("The server will start and wait for input. Press Ctrl+C to stop.")
-    print()
 
 
 if __name__ == "__main__":

second_opinion_mcp/server.py

@@ -1523,13 +1523,121 @@ def _sync_cleanup():
 atexit.register(_sync_cleanup)
 
 
+def _check_provider_keys() -> tuple[list[str], list[str]]:
+    """Check which enabled providers have API keys configured.
+
+    Returns:
+        (configured_providers, missing_providers) tuple
+    """
+    configured = []
+    missing = []
+
+    for provider, config in MODELS.items():
+        if not config.get("enabled"):
+            continue
+
+        try:
+            key = keyring.get_password(config["keyring_service"], config["keyring_name"])
+            if key:
+                configured.append(provider)
+            else:
+                missing.append(provider)
+        except Exception:
+            missing.append(provider)
+
+    return configured, missing
+
+
+def _validate_startup_requirements() -> tuple[bool, str]:
+    """Validate that minimum requirements are met to run the server.
+
+    Returns:
+        (ok, error_message) tuple. If ok is False, server should not start.
+    """
+    configured, missing = _check_provider_keys()
+
+    if len(configured) == 0:
+        return False, (
+            "No API keys configured. Run 'second-opinion-mcp setup' to configure providers.\n\n"
+            "Or manually configure keys:\n"
+            "  python -c \"import keyring; keyring.set_password('second-opinion', 'deepseek', 'YOUR_KEY')\"\n"
+            "  python -c \"import keyring; keyring.set_password('second-opinion', 'moonshot', 'YOUR_KEY')\"\n"
+        )
+
+    if len(configured) == 1:
+        return False, (
+            f"Only 1 provider configured ({configured[0]}). At least 2 providers required.\n\n"
+            "The 'consensus' tool requires multiple models to debate.\n"
+            "Run 'second-opinion-mcp setup' to add another provider.\n\n"
+            f"Missing: {', '.join(missing) if missing else 'none enabled'}\n"
+        )
+
+    return True, ""
+
+
+def _check_for_updates() -> tuple[str | None, str | None]:
+    """Check PyPI for newer version of second-opinion-mcp.
+
+    Returns:
+        (latest_version, current_version) if update available, (None, None) otherwise.
+    """
+    import urllib.request
+    import json
+
+    try:
+        from second_opinion_mcp import __version__ as current_version
+    except ImportError:
+        current_version = "0.0.0"
+
+    try:
+        # Quick timeout to not delay startup
+        url = "https://pypi.org/pypi/second-opinion-mcp/json"
+        req = urllib.request.Request(url, headers={"User-Agent": "second-opinion-mcp"})
+        with urllib.request.urlopen(req, timeout=3) as response:
+            data = json.loads(response.read().decode())
+            latest_version = data.get("info", {}).get("version", "0.0.0")
+
+            # Simple version comparison (works for semver)
+            def parse_version(v: str) -> tuple[int, ...]:
+                return tuple(int(x) for x in v.split(".")[:3] if x.isdigit())
+
+            if parse_version(latest_version) > parse_version(current_version):
+                return latest_version, current_version
+
+    except Exception:
+        # Don't fail startup on update check errors
+        pass
+
+    return None, None
+
+
 def main():
     """Run the MCP server with stdio transport."""
+    import sys
+
     # Configure logging when run directly (not when imported as library)
     logging.basicConfig(
         level=logging.INFO,
         format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
     )
+
+    # Check for updates (non-blocking, quick timeout)
+    latest, current = _check_for_updates()
+    if latest:
+        print(f"Update available: {current} -> {latest}", file=sys.stderr)
+        print("Run: pipx upgrade second-opinion-mcp", file=sys.stderr)
+        print(file=sys.stderr)
+
+    # Validate minimum requirements
+    ok, error = _validate_startup_requirements()
+    if not ok:
+        print(f"Error: {error}", file=sys.stderr)
+        sys.exit(1)
+
+    # Log configured providers
+    configured, _ = _check_provider_keys()
+    logger.info("Starting with providers: %s", ", ".join(configured))
+
     mcp.run(transport="stdio")
 
 

{second_opinion_mcp-0.3.0.dist-info → second_opinion_mcp-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: second-opinion-mcp
-Version: 0.3.0
+Version: 0.3.2
 Summary: Multi-model AI analysis for Claude - get second opinions from DeepSeek, Kimi, and OpenRouter
 Project-URL: Homepage, https://github.com/MarvinFS/second-opinion-mcp
 Project-URL: Repository, https://github.com/MarvinFS/second-opinion-mcp
@@ -279,6 +279,25 @@ Use code_review with focus_areas=["security", "error-handling", "performance"]
 Use code_review on directory="./src" with save_to="./docs/reviews"
 ```
 
+## Updating
+
+The server checks for updates on startup and notifies you if a new version is available.
+
+To update manually:
+
+```bash
+pipx upgrade second-opinion-mcp
+```
+
+Or reinstall:
+
+```bash
+pipx uninstall second-opinion-mcp
+pipx install second-opinion-mcp
+```
+
+Your API keys are preserved in the system keyring across updates.
+
 ## Uninstalling
 
 ```bash

second_opinion_mcp-0.3.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+second_opinion_mcp/__init__.py,sha256=6XCWg4mcxORq2OPxzaC5bVTLmKWEnYok4SWiZ5E6RVs,373
+second_opinion_mcp/__main__.py,sha256=WDv19O6nvIH69GR_DUfXqDt-wm8bgsHNqvPm1LEIKzs,509
+second_opinion_mcp/cli.py,sha256=A88Y0TZQ_B38YliHKzohAOLTZuGdMZzH4bEjyC1Tv_A,15279
+second_opinion_mcp/server.py,sha256=46cHbK0GgL0VBCGI3gmTA1-vQ1jRDdQ6MsCCqWw3LVk,62237
+second_opinion_mcp-0.3.2.dist-info/METADATA,sha256=azoIPNQyVezi-cYoift_BL4RN61qj7PI0Kqqvj2Bosg,8806
+second_opinion_mcp-0.3.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+second_opinion_mcp-0.3.2.dist-info/entry_points.txt,sha256=-E8BA2gFyU4qW-kJL8SV9Pg1Cc7glOCmraJoZH0PZP8,72
+second_opinion_mcp-0.3.2.dist-info/licenses/LICENSE,sha256=dPx2Jy-Ejearvfh6IlF2PN4Srt-nZW8M4bW5EW7RPAg,1065
+second_opinion_mcp-0.3.2.dist-info/RECORD,,

second_opinion_mcp-0.3.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-second_opinion_mcp/__init__.py,sha256=NpyIXDQRLwIAokC8JkOznUSIeX_sez7LjviT_Pg_ihM,373
-second_opinion_mcp/__main__.py,sha256=WDv19O6nvIH69GR_DUfXqDt-wm8bgsHNqvPm1LEIKzs,509
-second_opinion_mcp/cli.py,sha256=waLZH3Av817-3qqu3iG-GZ7YivF3Rp-7h9DzJ5YHgvo,8154
-second_opinion_mcp/server.py,sha256=vD2Cl64PfblmDy1oqM1mwF5V8ouMSLFgzttymFq6UxA,58589
-second_opinion_mcp-0.3.0.dist-info/METADATA,sha256=OqqHisGgVdSRtaHbsfkxlFc_JPsTahJSH7G6JbfZ6n4,8476
-second_opinion_mcp-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-second_opinion_mcp-0.3.0.dist-info/entry_points.txt,sha256=-E8BA2gFyU4qW-kJL8SV9Pg1Cc7glOCmraJoZH0PZP8,72
-second_opinion_mcp-0.3.0.dist-info/licenses/LICENSE,sha256=dPx2Jy-Ejearvfh6IlF2PN4Srt-nZW8M4bW5EW7RPAg,1065
-second_opinion_mcp-0.3.0.dist-info/RECORD,,