mcp-ticketer 0.1.30__py3-none-any.whl → 1.2.11__py3-none-any.whl

mcp_ticketer/cli/codex_configure.py

@@ -4,19 +4,15 @@ Codex CLI only supports global configuration at ~/.codex/config.toml.
 Unlike Claude Code and Gemini CLI, there is no project-level configuration support.
 """
 
-import sys
 from pathlib import Path
-from typing import Any, Dict, Optional
-
-if sys.version_info >= (3, 11):
-    import tomllib
-else:
-    import tomli as tomllib
+from typing import Any
 
 import tomli_w
+import tomllib
 from rich.console import Console
 
-from .mcp_configure import find_mcp_ticketer_binary, load_project_config
+from .mcp_configure import load_project_config
+from .python_detection import get_mcp_ticketer_python
 
 console = Console()
 
@@ -28,6 +24,7 @@ def find_codex_config() -> Path:
     No project-level or user-scoped configuration is available.
 
     Returns:
+    -------
         Path to Codex global config file at ~/.codex/config.toml
 
     """
@@ -36,13 +33,15 @@ def find_codex_config() -> Path:
     return config_path
 
 
-def load_codex_config(config_path: Path) -> Dict[str, Any]:
+def load_codex_config(config_path: Path) -> dict[str, Any]:
     """Load existing Codex configuration or return empty structure.
 
     Args:
+    ----
         config_path: Path to Codex config.toml file
 
     Returns:
+    -------
         Codex configuration dict with mcp_servers section
 
     """
@@ -61,10 +60,11 @@ def load_codex_config(config_path: Path) -> Dict[str, Any]:
     return {"mcp_servers": {}}
 
 
-def save_codex_config(config_path: Path, config: Dict[str, Any]) -> None:
+def save_codex_config(config_path: Path, config: dict[str, Any]) -> None:
     """Save Codex configuration to TOML file.
 
     Args:
+    ----
         config_path: Path to Codex config.toml file
         config: Configuration to save
 
@@ -78,79 +78,219 @@ def save_codex_config(config_path: Path, config: Dict[str, Any]) -> None:
 
 
 def create_codex_server_config(
-    binary_path: str, project_config: dict, cwd: Optional[str] = None
-) -> Dict[str, Any]:
+    python_path: str, project_config: dict, project_path: str | None = None
+) -> dict[str, Any]:
     """Create Codex MCP server configuration for mcp-ticketer.
 
+    Uses the CLI command (mcp-ticketer mcp) which implements proper
+    Content-Length framing via FastMCP SDK, required for modern MCP clients.
+
     Args:
-        binary_path: Path to mcp-ticketer binary
+    ----
+        python_path: Path to Python executable in mcp-ticketer venv
         project_config: Project configuration from .mcp-ticketer/config.json
-        cwd: Working directory for server (optional, not used for global config)
+        project_path: Project directory path (optional)
 
     Returns:
+    -------
         Codex MCP server configuration dict
 
     """
-    # Get adapter configuration
-    adapter = project_config.get("default_adapter", "aitrackdown")
-    adapters_config = project_config.get("adapters", {})
-    adapter_config = adapters_config.get(adapter, {})
-
-    # Build environment variables
-    env_vars: Dict[str, str] = {}
-
-    # Add PYTHONPATH if running from development environment
-    if cwd:
-        env_vars["PYTHONPATH"] = str(Path(cwd) / "src")
-
-    # Add adapter type
-    env_vars["MCP_TICKETER_ADAPTER"] = adapter
-
-    # Add adapter-specific environment variables
-    if adapter == "aitrackdown":
-        # Set base path for local adapter
-        base_path = adapter_config.get("base_path", ".aitrackdown")
-        if cwd:
-            # Use absolute path if cwd is provided
-            env_vars["MCP_TICKETER_BASE_PATH"] = str(Path(cwd) / base_path)
-        else:
-            env_vars["MCP_TICKETER_BASE_PATH"] = base_path
-
-    elif adapter == "linear":
-        if "api_key" in adapter_config:
-            env_vars["LINEAR_API_KEY"] = adapter_config["api_key"]
-        if "team_id" in adapter_config:
-            env_vars["LINEAR_TEAM_ID"] = adapter_config["team_id"]
-
-    elif adapter == "github":
-        if "token" in adapter_config:
-            env_vars["GITHUB_TOKEN"] = adapter_config["token"]
-        if "owner" in adapter_config:
-            env_vars["GITHUB_OWNER"] = adapter_config["owner"]
-        if "repo" in adapter_config:
-            env_vars["GITHUB_REPO"] = adapter_config["repo"]
-
-    elif adapter == "jira":
-        if "api_token" in adapter_config:
-            env_vars["JIRA_API_TOKEN"] = adapter_config["api_token"]
-        if "email" in adapter_config:
-            env_vars["JIRA_EMAIL"] = adapter_config["email"]
-        if "server" in adapter_config:
-            env_vars["JIRA_SERVER"] = adapter_config["server"]
-        if "project_key" in adapter_config:
-            env_vars["JIRA_PROJECT_KEY"] = adapter_config["project_key"]
+    # IMPORTANT: Use CLI command, NOT Python module invocation
+    # The CLI uses FastMCP SDK which implements proper Content-Length framing
+    # Legacy python -m mcp_ticketer.mcp.server uses line-delimited JSON (incompatible)
+
+    # Get mcp-ticketer CLI path from Python path
+    # If python_path is /path/to/venv/bin/python, CLI is /path/to/venv/bin/mcp-ticketer
+    python_dir = Path(python_path).parent
+    cli_path = str(python_dir / "mcp-ticketer")
+
+    # Build CLI arguments
+    args = ["mcp"]
+    if project_path:
+        args.extend(["--path", project_path])
 
     # Create server configuration with Codex-specific structure
-    # NOTE: Codex uses nested dict structure for env vars
-    config: Dict[str, Any] = {
-        "command": binary_path,
-        "args": ["serve"],
-        "env": env_vars,
+    # No environment variables needed - config loaded from .mcp-ticketer/config.json
+    config: dict[str, Any] = {
+        "command": cli_path,
+        "args": args,
     }
 
     return config
 
 
+def _test_configuration(adapter: str, project_config: dict) -> bool:
+    """Test the configuration by validating adapter credentials.
+
+    Args:
+    ----
+        adapter: Adapter type (linear, github, jira, aitrackdown)
+        project_config: Project configuration dict
+
+    Returns:
+    -------
+        True if validation passed, False otherwise
+
+    """
+    try:
+        from ..core import AdapterRegistry
+
+        # Get adapter configuration
+        adapters_config = project_config.get("adapters", {})
+        adapter_config = adapters_config.get(adapter, {})
+
+        # Test adapter instantiation
+        console.print(f"  Testing {adapter} adapter...")
+
+        try:
+            adapter_instance = AdapterRegistry.get_adapter(adapter, adapter_config)
+            console.print("  [green]✓[/green] Adapter instantiated successfully")
+
+            # Test credentials if validation method exists
+            if hasattr(adapter_instance, "validate_credentials"):
+                console.print(f"  Validating {adapter} credentials...")
+                is_valid, error_msg = adapter_instance.validate_credentials()
+
+                if is_valid:
+                    console.print("  [green]✓[/green] Credentials are valid")
+                    return True
+                else:
+                    console.print(
+                        f"  [red]✗[/red] Credential validation failed: {error_msg}"
+                    )
+                    return False
+            else:
+                # No validation method, assume valid
+                console.print(
+                    f"  [yellow]○[/yellow] No credential validation available for {adapter}"
+                )
+                return True
+
+        except Exception as e:
+            console.print(f"  [red]✗[/red] Adapter instantiation failed: {e}")
+
+            # Provide helpful error messages based on adapter type
+            if adapter == "linear":
+                console.print(
+                    "\n  [yellow]Linear requires:[/yellow] LINEAR_API_KEY and LINEAR_TEAM_ID"
+                )
+            elif adapter == "github":
+                console.print(
+                    "\n  [yellow]GitHub requires:[/yellow] GITHUB_TOKEN, GITHUB_OWNER, GITHUB_REPO"
+                )
+            elif adapter == "jira":
+                console.print(
+                    "\n  [yellow]JIRA requires:[/yellow] JIRA_SERVER, JIRA_EMAIL, JIRA_API_TOKEN"
+                )
+
+            return False
+
+    except Exception as e:
+        console.print(f"  [red]✗[/red] Configuration test error: {e}")
+        return False
+
+
+def detect_legacy_config(config_path: Path) -> tuple[bool, dict[str, Any] | None]:
+    """Detect if existing config uses legacy Python module invocation.
+
+    Args:
+    ----
+        config_path: Path to Codex config.toml file
+
+    Returns:
+    -------
+        Tuple of (is_legacy, server_config):
+        - is_legacy: True if config uses 'python -m mcp_ticketer.mcp.server'
+        - server_config: The legacy server config dict, or None if not legacy
+
+    """
+    if not config_path.exists():
+        return False, None
+
+    codex_config = load_codex_config(config_path)
+    mcp_servers = codex_config.get("mcp_servers", {})
+
+    if "mcp-ticketer" in mcp_servers:
+        server_config = mcp_servers["mcp-ticketer"]
+        args = server_config.get("args", [])
+
+        # Check for legacy pattern: ["-m", "mcp_ticketer.mcp.server", ...]
+        if len(args) >= 2 and args[0] == "-m" and "mcp_ticketer.mcp.server" in args[1]:
+            return True, server_config
+
+    return False, None
+
+
+def remove_codex_mcp(dry_run: bool = False) -> None:
+    """Remove mcp-ticketer from Codex CLI configuration.
+
+    IMPORTANT: Codex CLI ONLY supports global configuration at ~/.codex/config.toml.
+    This will remove mcp-ticketer from the global configuration.
+
+    Args:
+    ----
+        dry_run: Show what would be removed without making changes
+
+    """
+    # Step 1: Find Codex config location (always global)
+    console.print("[cyan]🔍 Removing Codex CLI global configuration...[/cyan]")
+    console.print(
+        "[yellow]⚠ Note: Codex CLI only supports global configuration[/yellow]"
+    )
+
+    codex_config_path = find_codex_config()
+    console.print(f"[dim]Config location: {codex_config_path}[/dim]")
+
+    # Step 2: Check if config file exists
+    if not codex_config_path.exists():
+        console.print(
+            f"[yellow]⚠ No configuration found at {codex_config_path}[/yellow]"
+        )
+        console.print("[dim]mcp-ticketer is not configured for Codex CLI[/dim]")
+        return
+
+    # Step 3: Load existing Codex configuration
+    codex_config = load_codex_config(codex_config_path)
+
+    # Step 4: Check if mcp-ticketer is configured
+    # NOTE: Use underscore mcp_servers, not camelCase
+    mcp_servers = codex_config.get("mcp_servers", {})
+    if "mcp-ticketer" not in mcp_servers:
+        console.print("[yellow]⚠ mcp-ticketer is not configured[/yellow]")
+        console.print(f"[dim]No mcp-ticketer entry found in {codex_config_path}[/dim]")
+        return
+
+    # Step 5: Show what would be removed (dry run or actual removal)
+    if dry_run:
+        console.print("\n[cyan]DRY RUN - Would remove:[/cyan]")
+        console.print("  Server name: mcp-ticketer")
+        console.print(f"  From: {codex_config_path}")
+        console.print("  Scope: Global (all sessions)")
+        return
+
+    # Step 6: Remove mcp-ticketer from configuration
+    del codex_config["mcp_servers"]["mcp-ticketer"]
+
+    # Step 7: Save updated configuration
+    try:
+        save_codex_config(codex_config_path, codex_config)
+        console.print("\n[green]✓ Successfully removed mcp-ticketer[/green]")
+        console.print(f"[dim]Configuration updated: {codex_config_path}[/dim]")
+
+        # Next steps
+        console.print("\n[bold cyan]Next Steps:[/bold cyan]")
+        console.print("1. [bold]Restart Codex CLI[/bold] (required for changes)")
+        console.print("2. mcp-ticketer will no longer be available via MCP")
+        console.print(
+            "\n[yellow]⚠ Note: This removes global configuration affecting all Codex sessions[/yellow]"
+        )
+
+    except Exception as e:
+        console.print(f"\n[red]✗ Failed to update configuration:[/red] {e}")
+        raise
+
+
 def configure_codex_mcp(force: bool = False) -> None:
     """Configure Codex CLI to use mcp-ticketer.
 
@@ -160,21 +300,27 @@ def configure_codex_mcp(force: bool = False) -> None:
     After configuration, you must restart Codex CLI for changes to take effect.
 
     Args:
+    ----
         force: Overwrite existing configuration
 
     Raises:
-        FileNotFoundError: If binary or project config not found
+    ------
+        FileNotFoundError: If Python executable or project config not found
         ValueError: If configuration is invalid
 
     """
-    # Step 1: Find mcp-ticketer binary
-    console.print("[cyan]🔍 Finding mcp-ticketer binary...[/cyan]")
+    # Step 1: Find Python executable
+    console.print("[cyan]🔍 Finding mcp-ticketer Python executable...[/cyan]")
     try:
-        binary_path = find_mcp_ticketer_binary()
-        console.print(f"[green]✓[/green] Found: {binary_path}")
-    except FileNotFoundError as e:
-        console.print(f"[red]✗[/red] {e}")
-        raise
+        python_path = get_mcp_ticketer_python()
+        console.print(f"[green]✓[/green] Found: {python_path}")
+    except Exception as e:
+        console.print(f"[red]✗[/red] Could not find Python executable: {e}")
+        raise FileNotFoundError(
+            "Could not find mcp-ticketer Python executable. "
+            "Please ensure mcp-ticketer is installed.\n"
+            "Install with: pip install mcp-ticketer or pipx install mcp-ticketer"
+        ) from e
 
     # Step 2: Load project configuration
     console.print("\n[cyan]📖 Reading project configuration...[/cyan]")
@@ -195,6 +341,26 @@ def configure_codex_mcp(force: bool = False) -> None:
     codex_config_path = find_codex_config()
     console.print(f"[dim]Config location: {codex_config_path}[/dim]")
 
+    # Step 3.5: Check for legacy configuration (DETECTION & MIGRATION)
+    is_legacy, legacy_config = detect_legacy_config(codex_config_path)
+    if is_legacy:
+        console.print("\n[yellow]⚠ LEGACY CONFIGURATION DETECTED[/yellow]")
+        console.print(
+            "[yellow]Your current configuration uses the legacy line-delimited JSON server:[/yellow]"
+        )
+        console.print(f"[dim]  Command: {legacy_config.get('command')}[/dim]")
+        console.print(f"[dim]  Args: {legacy_config.get('args')}[/dim]")
+        console.print(
+            "\n[red]This legacy server is incompatible with modern MCP clients (Codex, Claude Desktop/Code).[/red]"
+        )
+        console.print(
+            "[red]The legacy server uses line-delimited JSON instead of Content-Length framing.[/red]"
+        )
+        console.print(
+            "\n[cyan]✨ Automatically migrating to modern FastMCP-based server...[/cyan]"
+        )
+        force = True  # Auto-enable force mode for migration
+
     # Step 4: Load existing Codex configuration
     codex_config = load_codex_config(codex_config_path)
 
@@ -207,13 +373,17 @@ def configure_codex_mcp(force: bool = False) -> None:
             console.print("[dim]Use --force to overwrite existing configuration[/dim]")
             return
         else:
-            console.print("[yellow]⚠ Overwriting existing configuration[/yellow]")
+            if not is_legacy:
+                console.print("[yellow]⚠ Overwriting existing configuration[/yellow]")
+            # If is_legacy, we already printed migration message above
 
     # Step 6: Create mcp-ticketer server config
     # For global config, include current working directory for context
-    cwd = str(Path.cwd())
+    project_path = str(Path.cwd())
     server_config = create_codex_server_config(
-        binary_path=binary_path, project_config=project_config, cwd=cwd
+        python_path=python_path,
+        project_config=project_config,
+        project_path=project_path,
     )
 
     # Step 7: Update Codex configuration
@@ -232,12 +402,34 @@ def configure_codex_mcp(force: bool = False) -> None:
         console.print("\n[bold]Configuration Details:[/bold]")
         console.print("  Server name: mcp-ticketer")
         console.print(f"  Adapter: {adapter}")
-        console.print(f"  Binary: {binary_path}")
+        console.print(f"  Python: {python_path}")
+        console.print(f"  Command: {server_config.get('command')}")
+        console.print(f"  Args: {server_config.get('args')}")
+        console.print("  Protocol: Content-Length framing (FastMCP SDK)")
         console.print("  Scope: global (Codex only supports global config)")
-        console.print(f"  Working directory: {cwd}")
-        if "env" in server_config:
+        console.print(f"  Project path: {project_path}")
+
+        # Step 9: Test configuration
+        console.print("\n[cyan]🧪 Testing configuration...[/cyan]")
+        test_success = _test_configuration(adapter, project_config)
+
+        if not test_success:
+            console.print(
+                "[yellow]⚠ Configuration saved but validation failed. "
+                "Please check your credentials and settings.[/yellow]"
+            )
+
+        # Migration success message (if legacy config was detected)
+        if is_legacy:
+            console.print("\n[green]✅ Migration Complete![/green]")
+            console.print(
+                "[green]Your configuration has been upgraded from legacy line-delimited JSON[/green]"
+            )
+            console.print(
+                "[green]to modern Content-Length framing (FastMCP SDK).[/green]"
+            )
             console.print(
-                f"  Environment variables: {list(server_config['env'].keys())}"
+                "\n[cyan]This fixes MCP connection issues with Codex and other modern clients.[/cyan]"
             )
 
         # Next steps