refactor: update MCP clients and tool configurations

Author: zhujian0805

code_assistant_manager/copilot_models.py

@@ -129,23 +129,27 @@ def list_models():
     load_env()
     logger.debug("Environment variables loaded")
 
-    github_token = os.environ.get("GITHUB_TOKEN")
-    if not github_token:
-        logger.error("GITHUB_TOKEN environment variable is required but not found")
-        raise SystemExit("GITHUB_TOKEN environment variable is required")
-
-    logger.debug("Starting Copilot token refresh loop")
-    state = {}
-    start_refresh_loop(github_token, state)
-
-    time.sleep(1)
-
-    copilot_token = state.get("copilot_token")
-    if not copilot_token:
-        logger.debug("No token in state, fetching directly")
-        info = get_copilot_token(github_token)
-        copilot_token = info["token"]
-        state["copilot_token"] = copilot_token
+    # If EndpointManager provided an API key (proxy mode), we don't need GitHub token auth.
+    if os.environ.get("api_key"):
+        copilot_token = ""
+    else:
+        github_token = os.environ.get("GITHUB_TOKEN")
+        if not github_token:
+            logger.error("GITHUB_TOKEN environment variable is required but not found")
+            raise SystemExit("GITHUB_TOKEN environment variable is required")
+
+        logger.debug("Starting Copilot token refresh loop")
+        state = {}
+        start_refresh_loop(github_token, state)
+
+        time.sleep(1)
+
+        copilot_token = state.get("copilot_token")
+        if not copilot_token:
+            logger.debug("No token in state, fetching directly")
+            info = get_copilot_token(github_token)
+            copilot_token = info["token"]
+            state["copilot_token"] = copilot_token
 
     # Get base URL from environment (set by EndpointManager) or from config
     base_url = os.environ.get("endpoint")

code_assistant_manager/mcp/__init__.py

@@ -10,6 +10,7 @@
     ClaudeMCPClient,
     CodeBuddyMCPClient,
     CodexMCPClient,
+    ContinueMCPClient,
     CopilotMCPClient,
     CrushMCPClient,
     CursorAgentMCPClient,
@@ -42,4 +43,5 @@
     "QoderCLIMCPClient",
     "NeovateMCPClient",
     "OpenCodeMCPClient",
+    "ContinueMCPClient",
 ]

code_assistant_manager/mcp/clients.py

@@ -5,6 +5,7 @@
 from .codex import CodexMCPClient
 from .copilot import CopilotMCPClient
 from .crush import CrushMCPClient
+from .continue_mcp import ContinueMCPClient
 from .cursor import CursorAgentMCPClient
 from .droid import DroidMCPClient
 from .gemini import GeminiMCPClient
@@ -19,6 +20,7 @@
     "ClaudeMCPClient",
     "CodeBuddyMCPClient",
     "CodexMCPClient",
+    "ContinueMCPClient",
     "CopilotMCPClient",
     "CrushMCPClient",
     "CursorAgentMCPClient",

code_assistant_manager/mcp/continue_mcp.py

@@ -0,0 +1,181 @@
+"""Continue MCP client implementation."""
+
+from pathlib import Path
+
+import yaml
+
+from .base import print_squared_frame
+from .base_client import MCPClient
+
+
+class ContinueMCPClient(MCPClient):
+    """MCP client for Continue.dev."""
+
+    def __init__(self):
+        super().__init__("continue")
+
+    def _get_config_paths(self, scope: str):
+        home = Path.home()
+        if scope == "user":
+            return [home / ".continue" / "config.yaml"]
+        elif scope == "project":
+            return [Path.cwd() / ".continue" / "config.yaml"]
+        else:  # all
+            return [
+                home / ".continue" / "config.yaml",
+                Path.cwd() / ".continue" / "config.yaml",
+            ]
+
+    def _get_config_locations(self, tool_name: str):
+        # Used by list_servers()
+        return self._get_config_paths("all")
+
+    def _convert_server_config_to_client_format(self, server_config) -> dict:
+        # Continue uses the standard MCP "mcpServers" format (stdio/http)
+        return super()._convert_server_config_to_client_format(server_config)
+
+    def _add_server_config_to_file(
+        self, config_path, server_name: str, client_config: dict
+    ) -> bool:
+        config_path = Path(config_path)
+        try:
+            config = {}
+            if config_path.exists():
+                with open(config_path, "r", encoding="utf-8") as f:
+                    loaded = yaml.safe_load(f) or {}
+                    if isinstance(loaded, dict):
+                        config = loaded
+
+            if "mcpServers" not in config or not isinstance(
+                config.get("mcpServers"), dict
+            ):
+                config["mcpServers"] = {}
+
+            config["mcpServers"][server_name] = client_config
+
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(config_path, "w", encoding="utf-8") as f:
+                yaml.safe_dump(config, f, sort_keys=False)
+            return True
+        except Exception as e:
+            print(f"Error adding server to Continue config {config_path}: {e}")
+            return False
+
+    def add_server(self, server_name: str, scope: str = "user") -> bool:
+        server_config = self.get_server_config_from_registry(server_name)
+        if not server_config:
+            print_squared_frame(
+                f"{self.tool_name.upper()} - {server_name.upper()}",
+                f"Error: Server '{server_name}' not found in registry",
+            )
+            return False
+
+        client_config = self._convert_server_config_to_client_format(server_config)
+        config_paths = self._get_config_paths(scope)
+        for config_path in config_paths:
+            if self._add_server_config_to_file(config_path, server_name, client_config):
+                level = (
+                    "user-level" if config_path == config_paths[0] else "project-level"
+                )
+                print(
+                    f"✓ Successfully added {server_name} to {level} Continue configuration"
+                )
+                return True
+
+        print_squared_frame(
+            f"{self.tool_name.upper()} - {server_name.upper()}",
+            "Error: Failed to add server to any config file",
+        )
+        return False
+
+    def remove_server(self, server_name: str, scope: str = "user") -> bool:
+        config_paths = self._get_config_paths(scope)
+        removed_any = False
+
+        for config_path in config_paths:
+            config_path = Path(config_path)
+            if not config_path.exists():
+                continue
+
+            try:
+                with open(config_path, "r", encoding="utf-8") as f:
+                    config = yaml.safe_load(f) or {}
+                if not isinstance(config, dict):
+                    continue
+
+                if "mcpServers" in config and isinstance(config["mcpServers"], dict):
+                    if server_name in config["mcpServers"]:
+                        del config["mcpServers"][server_name]
+                        with open(config_path, "w", encoding="utf-8") as f:
+                            yaml.safe_dump(config, f, sort_keys=False)
+                        removed_any = True
+                        break
+            except Exception:
+                continue
+
+        if removed_any:
+            print(f"  Removed {server_name} from {self.tool_name} configuration")
+        else:
+            print(f"  {server_name} not found in {self.tool_name} configuration")
+        return removed_any
+
+    def list_servers(self, scope: str = "all") -> bool:
+        tool_configs = self.get_tool_config(self.tool_name)
+        if not tool_configs:
+            print(f"No MCP server configurations found for {self.tool_name}")
+            return False
+
+        config_locations = self._get_config_locations(self.tool_name)
+        user_servers = {}
+        project_servers = {}
+
+        home = Path.home()
+        cwd = Path.cwd()
+
+        for config_path in config_locations:
+            config_path = Path(config_path)
+            if not config_path.exists():
+                continue
+            try:
+                with open(config_path, "r", encoding="utf-8") as f:
+                    config = yaml.safe_load(f) or {}
+                if not isinstance(config, dict):
+                    continue
+                servers = config.get("mcpServers")
+                if not isinstance(servers, dict):
+                    continue
+
+                if config_path == home / ".continue" / "config.yaml":
+                    user_servers.update(servers)
+                elif config_path == cwd / ".continue" / "config.yaml":
+                    project_servers.update(servers)
+            except Exception:
+                continue
+
+        content_lines = []
+        show_user = scope in ["all", "user"]
+        show_project = scope in ["all", "project"]
+
+        if show_user and user_servers:
+            content_lines.append("User-level servers:")
+            content_lines.extend(
+                [f"  {name}: {cfg}" for name, cfg in user_servers.items()]
+            )
+            if show_project and project_servers:
+                content_lines.append("")
+
+        if show_project and project_servers:
+            content_lines.append("Project-level servers:")
+            content_lines.extend(
+                [f"  {name}: {cfg}" for name, cfg in project_servers.items()]
+            )
+
+        if content_lines:
+            print_squared_frame(
+                f"{self.tool_name.upper()} MCP SERVERS", "\n".join(content_lines)
+            )
+        else:
+            print_squared_frame(
+                f"{self.tool_name.upper()} MCP SERVERS", "No MCP servers configured"
+            )
+        return True

code_assistant_manager/mcp/manager.py

@@ -24,6 +24,7 @@ def _initialize_clients(
             CodexMCPClient,
             CopilotMCPClient,
             CrushMCPClient,
+            ContinueMCPClient,
             CursorAgentMCPClient,
             DroidMCPClient,
             GeminiMCPClient,
@@ -50,6 +51,7 @@ def _initialize_clients(
             "crush": CrushMCPClient(),
             "cursor-agent": CursorAgentMCPClient(),
             "opencode": OpenCodeMCPClient(),
+            "continue": ContinueMCPClient(),
         }
 
     def get_client(self, tool_name: str):