stravinsky 0.2.67__py3-none-any.whl → 0.4.66__py3-none-any.whl

mcp_bridge/server.py

@@ -7,22 +7,21 @@ Optimized for extremely fast startup and protocol compliance:
 - Robust crash logging to stderr and /tmp.
 """
 
-import sys
-import os
 import asyncio
 import logging
+import os
+import sys
 import time
 from typing import Any
 
 from mcp.server import Server
 from mcp.server.stdio import stdio_server
 from mcp.types import (
-    Tool,
-    TextContent,
-    Resource,
+    GetPromptResult,
     Prompt,
     PromptMessage,
-    GetPromptResult,
+    TextContent,
+    Tool,
 )
 
 from . import __version__
@@ -35,6 +34,26 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
+# --- LOAD .env FILES (GEMINI_API_KEY, etc.) ---
+# Load from ~/.stravinsky/.env (dedicated config location)
+try:
+    from pathlib import Path
+
+    from dotenv import load_dotenv
+
+    # Load from ~/.env (user-global, lowest priority)
+    home_env = Path.home() / ".env"
+    if home_env.exists():
+        load_dotenv(home_env, override=False)
+
+    # Load from ~/.stravinsky/.env (stravinsky config, takes precedence)
+    stravinsky_env = Path.home() / ".stravinsky" / ".env"
+    if stravinsky_env.exists():
+        load_dotenv(stravinsky_env, override=True)
+        logger.info(f"[Config] Loaded environment from {stravinsky_env}")
+except ImportError:
+    pass  # python-dotenv not installed, skip
+
 
 # Pre-async crash logger
 def install_emergency_logger():
@@ -95,56 +114,9 @@ async def list_tools() -> list[Tool]:
     return get_tool_definitions()
 
 
-def _format_tool_log(name: str, arguments: dict[str, Any]) -> str:
-    """Format a concise log message for tool calls."""
-    # LSP tools - show file:line
-    if name.startswith("lsp_"):
-        file_path = arguments.get("file_path", "")
-        if file_path:
-            # Shorten path to last 2 components
-            parts = file_path.split("/")
-            short_path = "/".join(parts[-2:]) if len(parts) > 2 else file_path
-            line = arguments.get("line", "")
-            if line:
-                return f"→ {name}: {short_path}:{line}"
-            return f"→ {name}: {short_path}"
-        query = arguments.get("query", "")
-        if query:
-            return f"→ {name}: query='{query[:40]}'"
-        return f"→ {name}"
-
-    # Model invocation - show agent context if present
-    if name in ("invoke_gemini", "invoke_openai"):
-        agent_ctx = arguments.get("agent_context", {})
-        agent_type = agent_ctx.get("agent_type", "direct") if agent_ctx else "direct"
-        model = arguments.get("model", "default")
-        prompt = arguments.get("prompt", "")
-        # Summarize prompt
-        summary = " ".join(prompt.split())[:80] + "..." if len(prompt) > 80 else prompt
-        return f"[{agent_type}] → {model}: {summary}"
-
-    # Search tools - show pattern
-    if name in ("grep_search", "ast_grep_search", "ast_grep_replace"):
-        pattern = arguments.get("pattern", "")[:50]
-        return f"→ {name}: pattern='{pattern}'"
-
-    # Agent tools - show agent type/task_id
-    if name == "agent_spawn":
-        agent_type = arguments.get("agent_type", "explore")
-        desc = arguments.get("description", "")[:40]
-        return f"→ {name}: [{agent_type}] {desc}"
-    if name in ("agent_output", "agent_cancel", "agent_progress"):
-        task_id = arguments.get("task_id", "")
-        return f"→ {name}: {task_id}"
-
-    # Default - just tool name
-    return f"→ {name}"
-
-
 @server.call_tool()
 async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
     """Handle tool calls with deep lazy loading of implementations."""
-    logger.info(_format_tool_log(name, arguments))
     hook_manager = get_hook_manager_lazy()
     token_store = get_token_store()
 
@@ -167,6 +139,17 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 thinking_budget=arguments.get("thinking_budget", 0),
             )
 
+        elif name == "invoke_gemini_agentic":
+            from .tools.model_invoke import invoke_gemini_agentic
+
+            result_content = await invoke_gemini_agentic(
+                token_store=token_store,
+                prompt=arguments["prompt"],
+                model=arguments.get("model", "gemini-3-flash"),
+                max_turns=arguments.get("max_turns", 10),
+                timeout=arguments.get("timeout", 120),
+            )
+
         elif name == "invoke_openai":
             from .tools.model_invoke import invoke_openai
 
@@ -177,6 +160,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 temperature=arguments.get("temperature", 0.7),
                 max_tokens=arguments.get("max_tokens", 4096),
                 thinking_budget=arguments.get("thinking_budget", 0),
+                reasoning_effort=arguments.get("reasoning_effort", "medium"),
             )
 
         # --- CONTEXT DISPATCH ---
@@ -190,6 +174,19 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
             result_content = await get_system_health()
 
+        elif name == "semantic_health":
+            from .tools.semantic_search import semantic_health
+
+            result_content = await semantic_health(
+                project_path=arguments.get("project_path", "."),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "lsp_health":
+            from .tools.lsp.tools import lsp_health
+
+            result_content = await lsp_health()
+
         # --- SEARCH DISPATCH ---
         elif name == "grep_search":
             from .tools.code_search import grep_search
@@ -200,6 +197,13 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 file_pattern=arguments.get("file_pattern", ""),
             )
 
+        elif name == "list_directory":
+            from .tools.list_directory import list_directory
+
+            result_content = await list_directory(
+                path=arguments["path"],
+            )
+
         elif name == "ast_grep_search":
             from .tools.code_search import ast_grep_search
 
@@ -228,6 +232,56 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 directory=arguments.get("directory", "."),
             )
 
+        elif name == "read_file":
+            from .tools.read_file import read_file
+
+            result_content = await read_file(
+                path=arguments["path"],
+                offset=arguments.get("offset", 0),
+                limit=arguments.get("limit"),
+            )
+
+        elif name == "write_file":
+            from .tools.write_file import write_file
+
+            result_content = await write_file(
+                path=arguments["path"],
+                content=arguments["content"],
+            )
+
+        elif name == "replace":
+            from .tools.replace import replace
+
+            result_content = await replace(
+                path=arguments["path"],
+                old_string=arguments["old_string"],
+                new_string=arguments["new_string"],
+                instruction=arguments["instruction"],
+                expected_replacements=arguments.get("expected_replacements", 1),
+            )
+
+        elif name == "run_shell_command":
+            from .tools.run_shell_command import run_shell_command
+
+            result_content = await run_shell_command(
+                command=arguments["command"],
+                description=arguments["description"],
+                dir_path=arguments.get("dir_path", "."),
+            )
+
+        elif name == "tool_search":
+            from .tools.tool_search import search_tools
+            from .server_tools import get_tool_definitions
+
+            # Get all registered tool definitions to search through
+            all_tools = get_tool_definitions()
+
+            result_content = search_tools(
+                query=arguments["query"],
+                tools=all_tools,
+                top_k=arguments.get("top_k", 5),
+            )
+
         # --- SESSION DISPATCH ---
         elif name == "session_list":
             from .tools.session_manager import list_sessions
@@ -318,7 +372,15 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
         elif name == "agent_list":
             from .tools.agent_manager import agent_list
 
-            result_content = await agent_list()
+            result_content = await agent_list(show_all=arguments.get("show_all", True))
+
+        elif name == "agent_cleanup":
+            from .tools.agent_manager import agent_cleanup
+
+            result_content = await agent_cleanup(
+                max_age_minutes=arguments.get("max_age_minutes", 30),
+                statuses=arguments.get("statuses"),
+            )
 
         elif name == "agent_progress":
             from .tools.agent_manager import agent_progress
@@ -423,6 +485,28 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 character=arguments["character"],
             )
 
+        elif name == "lsp_code_action_resolve":
+            from .tools.lsp import lsp_code_action_resolve
+
+            result_content = await lsp_code_action_resolve(
+                file_path=arguments["file_path"],
+                action_code=arguments["action_code"],
+                line=arguments.get("line"),
+            )
+
+        elif name == "lsp_extract_refactor":
+            from .tools.lsp import lsp_extract_refactor
+
+            result_content = await lsp_extract_refactor(
+                file_path=arguments["file_path"],
+                start_line=arguments["start_line"],
+                start_char=arguments["start_char"],
+                end_line=arguments["end_line"],
+                end_char=arguments["end_char"],
+                new_name=arguments["new_name"],
+                kind=arguments.get("kind", "function"),
+            )
+
         elif name == "lsp_servers":
             from .tools.lsp import lsp_servers
 
@@ -436,6 +520,222 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 severity=arguments.get("severity", "all"),
             )
 
+        elif name == "semantic_search":
+            from .tools.semantic_search import semantic_search
+
+            result_content = await semantic_search(
+                query=arguments["query"],
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                language=arguments.get("language"),
+                node_type=arguments.get("node_type"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "hybrid_search":
+            from .tools.semantic_search import hybrid_search
+
+            result_content = await hybrid_search(
+                query=arguments["query"],
+                pattern=arguments.get("pattern"),
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                language=arguments.get("language"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "find_code":
+            from .tools.find_code import find_code
+
+            result_content = await find_code(
+                query=arguments["query"],
+                search_type=arguments.get("search_type", "auto"),
+                project_path=arguments.get("project_path", "."),
+                language=arguments.get("language"),
+                n_results=arguments.get("n_results", 10),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "multi_query_search":
+            from .tools.search_enhancements import multi_query_search
+
+            result_content = await multi_query_search(
+                query=arguments["query"],
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                num_expansions=arguments.get("num_expansions", 3),
+                language=arguments.get("language"),
+                node_type=arguments.get("node_type"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "decomposed_search":
+            from .tools.search_enhancements import decomposed_search
+
+            result_content = await decomposed_search(
+                query=arguments["query"],
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                language=arguments.get("language"),
+                node_type=arguments.get("node_type"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "enhanced_search":
+            from .tools.search_enhancements import enhanced_search
+
+            result_content = await enhanced_search(
+                query=arguments["query"],
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                mode=arguments.get("mode", "auto"),
+                language=arguments.get("language"),
+                node_type=arguments.get("node_type"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "get_cost_report":
+            from .tools.dashboard import get_cost_report
+
+            result_content = await get_cost_report(
+                session_id=arguments.get("session_id"),
+            )
+
+        elif name == "semantic_index":
+            from .tools.semantic_search import index_codebase
+
+            result_content = await index_codebase(
+                project_path=arguments.get("project_path", "."),
+                force=arguments.get("force", False),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "semantic_stats":
+            from .tools.semantic_search import semantic_stats
+
+            result_content = await semantic_stats(
+                project_path=arguments.get("project_path", "."),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "start_file_watcher":
+            import json
+
+            from .tools.semantic_search import start_file_watcher
+
+            try:
+                watcher = await start_file_watcher(
+                    project_path=arguments.get("project_path", "."),
+                    provider=arguments.get("provider", "ollama"),
+                    debounce_seconds=arguments.get("debounce_seconds", 2.0),
+                )
+
+                result_content = json.dumps(
+                    {
+                        "status": "started",
+                        "project_path": str(watcher.project_path),
+                        "debounce_seconds": watcher.debounce_seconds,
+                        "provider": watcher.store.provider_name,
+                        "is_running": watcher.is_running(),
+                    },
+                    indent=2,
+                )
+            except ValueError as e:
+                # No index exists
+                result_content = json.dumps(
+                    {"error": str(e), "hint": "Run semantic_index() before starting file watcher"},
+                    indent=2,
+                )
+                print(f"⚠️  start_file_watcher ValueError: {e}", file=sys.stderr)
+            except Exception as e:
+                # Unexpected error
+                import traceback
+
+                result_content = json.dumps(
+                    {
+                        "error": f"{type(e).__name__}: {str(e)}",
+                        "hint": "Check MCP server logs for details",
+                    },
+                    indent=2,
+                )
+                print(f"❌ start_file_watcher error: {e}", file=sys.stderr)
+                traceback.print_exc(file=sys.stderr)
+
+        elif name == "stop_file_watcher":
+            import json
+
+            from .tools.semantic_search import stop_file_watcher
+
+            stopped = stop_file_watcher(
+                project_path=arguments.get("project_path", "."),
+            )
+
+            result_content = json.dumps(
+                {"stopped": stopped, "project_path": arguments.get("project_path", ".")}, indent=2
+            )
+
+        elif name == "cancel_indexing":
+            from .tools.semantic_search import cancel_indexing
+
+            result_content = cancel_indexing(
+                project_path=arguments.get("project_path", "."),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "delete_index":
+            from .tools.semantic_search import delete_index
+
+            result_content = delete_index(
+                project_path=arguments.get("project_path", "."),
+                provider=arguments.get("provider"),  # None if not specified
+                delete_all=arguments.get("delete_all", False),
+            )
+
+        elif name == "list_file_watchers":
+            import json
+
+            from .tools.semantic_search import list_file_watchers
+
+            result_content = json.dumps(list_file_watchers(), indent=2)
+
+        elif name == "multi_query_search":
+            from .tools.semantic_search import multi_query_search
+
+            result_content = await multi_query_search(
+                query=arguments["query"],
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                num_expansions=arguments.get("num_expansions", 3),
+                language=arguments.get("language"),
+                node_type=arguments.get("node_type"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "decomposed_search":
+            from .tools.semantic_search import decomposed_search
+
+            result_content = await decomposed_search(
+                query=arguments["query"],
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                language=arguments.get("language"),
+                node_type=arguments.get("node_type"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "enhanced_search":
+            from .tools.semantic_search import enhanced_search
+
+            result_content = await enhanced_search(
+                query=arguments["query"],
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                mode=arguments.get("mode", "auto"),
+                language=arguments.get("language"),
+                node_type=arguments.get("node_type"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
         else:
             result_content = f"Unknown tool: {name}"
 
@@ -482,7 +782,7 @@ async def list_prompts() -> list[Prompt]:
 @server.get_prompt()
 async def get_prompt(name: str, arguments: dict[str, str] | None) -> GetPromptResult:
     """Get a specific prompt content (lazy loaded)."""
-    from .prompts import stravinsky, delphi, dewey, explore, frontend, document_writer, multimodal
+    from .prompts import delphi, dewey, document_writer, explore, frontend, multimodal, stravinsky
 
     prompts_map = {
         "stravinsky": ("Stravinsky orchestrator system prompt", stravinsky.get_stravinsky_prompt),
@@ -511,8 +811,105 @@ async def get_prompt(name: str, arguments: dict[str, str] | None) -> GetPromptRe
     )
 
 
+def sync_user_assets():
+    """
+    Copy package assets to user scope (~/.claude/) on every MCP load.
+
+    This ensures all repos get the latest commands, hooks, rules, and agents
+    from the installed Stravinsky package.
+
+    Handles both:
+    - Development: .claude/ relative to project root
+    - Installed package: stravinsky_claude_assets/ in site-packages
+    """
+    from pathlib import Path
+    import shutil
+
+    # Try multiple locations for package assets
+    package_dir = Path(__file__).parent.parent  # stravinsky/
+
+    # Location 1: Development - .claude/ at project root
+    dev_claude = package_dir / ".claude"
+
+    # Location 2: Installed package - stravinsky_claude_assets in site-packages
+    # When installed via pip/uvx, hatch includes .claude as stravinsky_claude_assets
+    installed_claude = package_dir / "stravinsky_claude_assets"
+
+    # Also check relative to mcp_bridge (alternate install layout)
+    mcp_bridge_dir = Path(__file__).parent
+    installed_claude_alt = mcp_bridge_dir.parent / "stravinsky_claude_assets"
+
+    # Find the first existing assets directory
+    package_claude = None
+    for candidate in [dev_claude, installed_claude, installed_claude_alt]:
+        if candidate.exists():
+            package_claude = candidate
+            break
+
+    # User scope directory
+    user_claude = Path.home() / ".claude"
+
+    if package_claude is None:
+        # Try importlib.resources as last resort (Python 3.9+)
+        try:
+            import importlib.resources as resources
+
+            # Check if stravinsky_claude_assets is a package
+            with resources.files("stravinsky_claude_assets") as assets_path:
+                if assets_path.is_dir():
+                    package_claude = Path(assets_path)
+        except (ImportError, ModuleNotFoundError, TypeError):
+            pass
+
+    if package_claude is None:
+        logger.debug(f"Package assets not found (checked: {dev_claude}, {installed_claude})")
+        return
+
+    # Directories to sync
+    dirs_to_sync = ["commands", "hooks", "rules", "agents"]
+
+    for dir_name in dirs_to_sync:
+        src_dir = package_claude / dir_name
+        dst_dir = user_claude / dir_name
+
+        if not src_dir.exists():
+            continue
+
+        # Create destination if it doesn't exist
+        dst_dir.mkdir(parents=True, exist_ok=True)
+
+        # Copy all files recursively (overwrite if source is newer)
+        for src_file in src_dir.rglob("*"):
+            if src_file.is_file():
+                # Compute relative path
+                rel_path = src_file.relative_to(src_dir)
+                dst_file = dst_dir / rel_path
+
+                # Create parent directories
+                dst_file.parent.mkdir(parents=True, exist_ok=True)
+
+                # Copy if source is newer or dest doesn't exist
+                should_copy = not dst_file.exists()
+                if dst_file.exists():
+                    src_mtime = src_file.stat().st_mtime
+                    dst_mtime = dst_file.stat().st_mtime
+                    should_copy = src_mtime > dst_mtime
+
+                if should_copy:
+                    shutil.copy2(src_file, dst_file)
+                    logger.debug(f"Synced {dir_name}/{rel_path} to user scope")
+
+    logger.info("Synced package assets to user scope (~/.claude/)")
+
+
 async def async_main():
     """Server execution entry point."""
+    # Sync package assets to user scope on every MCP load
+    try:
+        sync_user_assets()
+    except Exception as e:
+        logger.warning(f"Failed to sync user assets: {e}")
+
     # Initialize hooks at runtime, not import time
     try:
         from .hooks import initialize_hooks
@@ -521,6 +918,16 @@ async def async_main():
     except Exception as e:
         logger.error(f"Failed to initialize hooks: {e}")
 
+    # Clean up stale ChromaDB locks on startup
+    try:
+        from .tools.semantic_search import cleanup_stale_chromadb_locks
+
+        removed_count = cleanup_stale_chromadb_locks()
+        if removed_count > 0:
+            logger.info(f"Cleaned up {removed_count} stale ChromaDB lock(s)")
+    except Exception as e:
+        logger.warning(f"Failed to cleanup ChromaDB locks: {e}")
+
     # Start background token refresh scheduler
     try:
         from .auth.token_refresh import background_token_refresh
@@ -537,17 +944,23 @@ async def async_main():
                 write_stream,
                 server.create_initialization_options(),
             )
-    except Exception as e:
+    except Exception:
         logger.critical("Server process crashed in async_main", exc_info=True)
         sys.exit(1)
+    finally:
+        logger.info("Initiating shutdown sequence...")
+        from .tools.lsp.manager import get_lsp_manager
+
+        lsp_manager = get_lsp_manager()
+        await lsp_manager.shutdown()
 
 
 def main():
     """Synchronous entry point with CLI arg handling."""
     import argparse
-    import sys
-    from .tools.agent_manager import get_manager
+
     from .auth.token_store import TokenStore
+    from .tools.agent_manager import get_manager
 
     parser = argparse.ArgumentParser(
         description="Stravinsky MCP Bridge - Multi-model AI orchestration for Claude Code. "
@@ -597,6 +1010,31 @@ def main():
         help="Also clear agent history from .stravinsky/agents.json",
     )
 
+    # proxy command (model server proxy)
+    proxy_parser = subparsers.add_parser(
+        "proxy",
+        help="Manage the model proxy server",
+        description="Starts or manages the FastAPI model proxy for async execution.",
+    )
+    proxy_subparsers = proxy_parser.add_subparsers(
+        dest="proxy_command", help="Proxy subcommands", metavar="SUBCOMMAND"
+    )
+    proxy_subparsers.add_parser(
+        "start",
+        help="Start the model proxy server",
+        description="Launches the FastAPI server on port 8765.",
+    )
+    proxy_subparsers.add_parser(
+        "stop",
+        help="Stop the model proxy server",
+        description="Terminates any running model proxy process.",
+    )
+    proxy_subparsers.add_parser(
+        "status",
+        help="Check proxy server status",
+        description="Verifies if the proxy server is reachable.",
+    )
+
     # auth command (authentication)
     auth_parser = subparsers.add_parser(
         "auth",
@@ -708,6 +1146,51 @@ def main():
             print(f"Stopped {count} running agent(s).")
         return 0
 
+    elif args.command == "proxy":
+        proxy_cmd = getattr(args, "proxy_command", None)
+        import os
+        import sys
+
+        if proxy_cmd == "start":
+            from .proxy.model_server import main as proxy_main
+
+            proxy_main()
+            return 0
+        elif proxy_cmd == "stop":
+            # Simple kill-by-port for now
+            import os
+            import subprocess
+
+            port = int(os.getenv("STRAVINSKY_PROXY_PORT", 8765))
+            try:
+                if sys.platform == "win32":
+                    subprocess.run(
+                        f"taskkill /F /FI \"PID eq $(netstat -ano | findstr :{port} | awk '{{print $5}}')\"",
+                        shell=True,
+                    )
+                else:
+                    subprocess.run(f"lsof -ti:{port} | xargs kill -9", shell=True)
+                print(f"Stopped proxy on port {port}")
+            except Exception as e:
+                print(f"Failed to stop proxy: {e}")
+            return 0
+        elif proxy_cmd == "status":
+            import socket
+
+            port = int(os.getenv("STRAVINSKY_PROXY_PORT", 8765))
+            host = os.getenv("STRAVINSKY_PROXY_HOST", "127.0.0.1")
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.settimeout(1)
+                try:
+                    s.connect((host, port))
+                    print(f"✅ Proxy is RUNNING on {host}:{port}")
+                except Exception:
+                    print(f"❌ Proxy is NOT RUNNING on {host}:{port}")
+            return 0
+        else:
+            proxy_parser.print_help()
+            return 0
+
     elif args.command == "auth":
         auth_cmd = getattr(args, "auth_command", None)
         token_store = get_token_store()
@@ -752,4 +1235,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    sys.exit(main())