cli2api 0.2.0__tar.gz → 0.2.1__tar.gz

cli2api-0.2.1/.env.example

@@ -0,0 +1,32 @@
+# CLI2API Configuration
+# Copy this file to .env and customize as needed
+
+# Server settings
+CLI2API_HOST=0.0.0.0
+CLI2API_PORT=8000
+CLI2API_DEBUG=false
+
+# CLI executable path (auto-detected if not set)
+# Auto-detection checks (in order):
+#   1. Cached path (~/.cache/cli2api/claude_cli_path)
+#   2. System PATH (shutil.which)
+#   3. Running Claude processes (ps aux / wmic)
+#   4. VSCode extensions (~/.vscode/extensions/anthropic.claude-code-*)
+#   5. NPM global packages
+#   6. Common paths (/opt/homebrew/bin, /usr/local/bin, ~/.local/bin)
+#
+# Explicitly set if auto-detection fails or you want to override:
+# CLI2API_CLAUDE_CLI_PATH=/opt/homebrew/bin/claude
+# CLI2API_CLAUDE_CLI_PATH=/Users/username/.vscode/extensions/anthropic.claude-code-2.1.31-darwin-arm64/resources/native-binary/claude
+
+# Timeout (in seconds)
+CLI2API_DEFAULT_TIMEOUT=300
+
+# Default model
+CLI2API_DEFAULT_MODEL=sonnet
+
+# Custom models (comma-separated)
+# CLI2API_CLAUDE_MODELS=sonnet,opus,haiku
+
+# Logging
+CLI2API_LOG_LEVEL=INFO

{cli2api-0.2.0 → cli2api-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli2api
-Version: 0.2.0
+Version: 0.2.1
 Summary: OpenAI-compatible API over Claude Code CLI
 Requires-Python: >=3.11
 Requires-Dist: fastapi>=0.115.0

{cli2api-0.2.0 → cli2api-0.2.1}/cli2api/api/dependencies.py

@@ -29,7 +29,27 @@ def get_provider() -> ClaudeCodeProvider:
     """
     settings = get_settings()
     if not settings.claude_cli_path:
-        raise RuntimeError("Claude CLI not found. Set CLI2API_CLAUDE_CLI_PATH.")
+        error_msg = """
+Claude CLI not found. Please:
+
+1. Install Claude Code: https://docs.anthropic.com/en/docs/claude-code
+2. Or set environment variable: export CLI2API_CLAUDE_CLI_PATH=/path/to/claude
+3. Or ensure Claude is in your PATH
+
+Auto-detection checked:
+- Cached path (~/.cache/cli2api/claude_cli_path)
+- System PATH (shutil.which)
+- Running processes (ps aux / wmic)
+- VSCode extensions (platform-specific)
+- NPM global packages
+- Common paths (platform-specific)
+
+For debugging, run: CLI2API_LOG_LEVEL=DEBUG cli2api
+
+Note: Detected path is cached in ~/.cache/cli2api/claude_cli_path
+To force re-detection, delete the cache file.
+"""
+        raise RuntimeError(error_msg.strip())
 
     return ClaudeCodeProvider(
         executable_path=Path(settings.claude_cli_path),

{cli2api-0.2.0 → cli2api-0.2.1}/cli2api/config/settings.py

@@ -1,6 +1,5 @@
 """Application settings."""
 
-import shutil
 from pathlib import Path
 from typing import Optional
 
@@ -68,19 +67,33 @@ class Settings(BaseSettings):
     @classmethod
     def detect_claude_cli(cls, v: Optional[str]) -> Optional[str]:
         """Auto-detect claude CLI path if not provided."""
+        from cli2api.utils.cli_detector import (
+            cache_path,
+            detect_claude_cli,
+            verify_claude_executable,
+        )
+        from cli2api.utils.logging import get_logger
+
+        logger = get_logger(__name__)
+
         if v:
-            return v
-        # Try which first
-        path = shutil.which("claude")
-        if path:
-            return path
-        # Fallback to common paths
-        common_paths = [
-            "/opt/homebrew/bin/claude",
-            "/usr/local/bin/claude",
-            Path.home() / ".local/bin/claude",
-        ]
-        for p in common_paths:
-            if Path(p).exists():
-                return str(p)
+            # User explicitly set path - verify it
+            path = Path(v)
+            if verify_claude_executable(path):
+                logger.info(f"Using explicitly set Claude CLI path: {v}")
+                # Cache explicitly set path
+                cache_path(path)
+                return v
+            logger.warning(f"Explicitly set Claude CLI path is invalid: {v}")
+
+        # Auto-detect (includes cache check)
+        detected_path = detect_claude_cli()
+
+        if detected_path:
+            logger.info(f"Auto-detected Claude CLI: {detected_path}")
+            # Cache detected path for next startup
+            cache_path(detected_path)
+            return str(detected_path)
+
+        logger.error("Claude CLI not found")
         return None

cli2api-0.2.1/cli2api/utils/cli_detector.py

@@ -0,0 +1,337 @@
+"""Claude CLI auto-detection utilities with caching and cross-platform support."""
+
+import os
+import platform
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from cli2api.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+# Cache file location
+CACHE_FILE = Path.home() / ".cache" / "cli2api" / "claude_cli_path"
+
+
+def verify_claude_executable(path: Path) -> bool:
+    """Verify that the path is a valid Claude CLI executable.
+
+    Args:
+        path: Path to potential Claude CLI executable.
+
+    Returns:
+        True if the path is a valid, executable Claude CLI.
+    """
+    if not path.exists():
+        logger.debug(f"Path does not exist: {path}")
+        return False
+
+    if not path.is_file():
+        logger.debug(f"Path is not a file: {path}")
+        return False
+
+    if not os.access(path, os.X_OK):
+        logger.debug(f"Path is not executable: {path}")
+        return False
+
+    # Quick version check to confirm it's Claude
+    try:
+        result = subprocess.run(
+            [str(path), "--version"],
+            capture_output=True,
+            timeout=2,
+        )
+        if result.returncode == 0:
+            logger.debug(f"Valid Claude CLI found: {path}")
+            return True
+        else:
+            logger.debug(f"Claude CLI returned non-zero exit code: {path}")
+            return False
+    except (subprocess.TimeoutExpired, FileNotFoundError, PermissionError) as e:
+        logger.debug(f"Failed to verify Claude CLI at {path}: {e}")
+        return False
+
+
+def get_cached_path() -> Optional[Path]:
+    """Get cached Claude CLI path if still valid.
+
+    Returns:
+        Cached path if valid, None otherwise.
+    """
+    if not CACHE_FILE.exists():
+        logger.debug("No cache file found")
+        return None
+
+    try:
+        cached_path = Path(CACHE_FILE.read_text().strip())
+        if verify_claude_executable(cached_path):
+            logger.debug(f"Using cached Claude CLI path: {cached_path}")
+            return cached_path
+        else:
+            logger.debug("Cached path is invalid, removing cache")
+            CACHE_FILE.unlink(missing_ok=True)
+    except Exception as e:
+        logger.debug(f"Failed to read cache: {e}")
+
+    return None
+
+
+def cache_path(path: Path) -> None:
+    """Cache the detected Claude CLI path.
+
+    Args:
+        path: Path to cache.
+    """
+    try:
+        CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        CACHE_FILE.write_text(str(path))
+        logger.debug(f"Cached Claude CLI path: {path}")
+    except Exception as e:
+        logger.debug(f"Failed to cache path: {e}")
+
+
+def get_vscode_extensions_dir() -> Path:
+    """Get VSCode extensions directory for current OS.
+
+    Returns:
+        Path to VSCode extensions directory.
+    """
+    system = platform.system()
+    if system == "Windows":
+        return Path.home() / "AppData" / "Roaming" / "Code" / "extensions"
+    else:  # macOS and Linux
+        return Path.home() / ".vscode" / "extensions"
+
+
+def detect_from_path() -> Optional[Path]:
+    """Detect Claude CLI from system PATH.
+
+    Returns:
+        Path to Claude CLI if found in PATH, None otherwise.
+    """
+    logger.debug("Checking system PATH for Claude CLI")
+    path_str = shutil.which("claude")
+    if path_str:
+        path = Path(path_str)
+        if verify_claude_executable(path):
+            logger.info(f"Found Claude CLI in system PATH: {path}")
+            return path
+    logger.debug("Claude CLI not found in system PATH")
+    return None
+
+
+def detect_from_processes() -> Optional[Path]:
+    """Detect Claude CLI from running processes (cross-platform).
+
+    Returns:
+        Path to Claude CLI if found in running processes, None otherwise.
+    """
+    system = platform.system()
+    logger.debug(f"Checking running processes for Claude CLI on {system}")
+
+    try:
+        if system == "Windows":
+            # Windows: use wmic to get process executable paths
+            result = subprocess.run(
+                ["wmic", "process", "where", "name like '%claude%'", "get", "ExecutablePath"],
+                capture_output=True,
+                text=True,
+                timeout=2,
+            )
+            logger.debug(f"Windows process detection output (first 200 chars): {result.stdout[:200]}")
+
+            for line in result.stdout.splitlines():
+                line = line.strip()
+                if line and "claude" in line.lower() and Path(line).exists():
+                    path = Path(line)
+                    if verify_claude_executable(path):
+                        logger.info(f"Found Claude in running processes: {path}")
+                        return path
+        else:
+            # macOS/Linux: use ps aux
+            result = subprocess.run(
+                ["ps", "aux"],
+                capture_output=True,
+                text=True,
+                timeout=2,
+            )
+            logger.debug(f"Unix process detection found {len(result.stdout.splitlines())} processes")
+
+            for line in result.stdout.splitlines():
+                if "claude" in line.lower() and "native-binary" in line:
+                    parts = line.split()
+                    for part in parts:
+                        if "claude" in part and Path(part).exists():
+                            path = Path(part)
+                            if verify_claude_executable(path):
+                                logger.info(f"Found Claude in running processes: {path}")
+                                return path
+    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
+        logger.debug(f"Process detection failed: {e}")
+
+    logger.debug("No Claude CLI found in running processes")
+    return None
+
+
+def detect_from_vscode() -> Optional[Path]:
+    """Detect Claude CLI from VSCode extensions (cross-platform, version-agnostic).
+
+    Returns:
+        Path to Claude CLI if found in VSCode extensions, None otherwise.
+    """
+    vscode_dir = get_vscode_extensions_dir()
+    logger.debug(f"Checking VSCode extensions directory: {vscode_dir}")
+
+    if not vscode_dir.exists():
+        logger.debug(f"VSCode extensions directory not found: {vscode_dir}")
+        return None
+
+    # Pattern: anthropic.claude-code-*-{platform}
+    pattern = "anthropic.claude-code-*"
+    matches = sorted(vscode_dir.glob(pattern), reverse=True)  # Latest version first
+    logger.debug(f"Found {len(matches)} VSCode extension directories matching pattern")
+
+    for ext_dir in matches:
+        # Windows uses .exe
+        binary_name = "claude.exe" if platform.system() == "Windows" else "claude"
+        claude_path = ext_dir / "resources" / "native-binary" / binary_name
+
+        if verify_claude_executable(claude_path):
+            logger.info(f"Found Claude in VSCode extension: {ext_dir.name}")
+            return claude_path
+        else:
+            logger.debug(f"Invalid Claude binary in {ext_dir.name}")
+
+    logger.debug("No valid Claude CLI found in VSCode extensions")
+    return None
+
+
+def detect_from_npm() -> Optional[Path]:
+    """Detect Claude CLI from NPM global packages.
+
+    Returns:
+        Path to Claude CLI if found in NPM globals, None otherwise.
+    """
+    logger.debug("Checking NPM global packages for Claude CLI")
+
+    try:
+        # Get npm global directory
+        result = subprocess.run(
+            ["npm", "root", "-g"],
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+
+        if result.returncode == 0:
+            npm_root = Path(result.stdout.strip())
+            logger.debug(f"NPM global root: {npm_root}")
+
+            # Common npm package names for Claude
+            package_names = [
+                "@anthropic-ai/claude-code",
+                "claude-code",
+                "@anthropic/claude",
+            ]
+
+            for package_name in package_names:
+                package_dir = npm_root / package_name
+                if package_dir.exists():
+                    # Try common binary locations
+                    binary_paths = [
+                        package_dir / "bin" / "claude",
+                        package_dir / "bin" / "claude.exe",
+                        package_dir / "claude",
+                        package_dir / "claude.exe",
+                    ]
+
+                    for binary_path in binary_paths:
+                        if verify_claude_executable(binary_path):
+                            logger.info(f"Found Claude in NPM package: {package_name}")
+                            return binary_path
+
+    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
+        logger.debug(f"NPM detection failed: {e}")
+
+    logger.debug("No Claude CLI found in NPM global packages")
+    return None
+
+
+def detect_from_common_paths() -> Optional[Path]:
+    """Detect Claude CLI from common installation paths (cross-platform).
+
+    Returns:
+        Path to Claude CLI if found in common paths, None otherwise.
+    """
+    logger.debug("Checking common installation paths for Claude CLI")
+
+    system = platform.system()
+
+    if system == "Windows":
+        common_paths = [
+            Path("C:/Program Files/Claude/claude.exe"),
+            Path("C:/Program Files (x86)/Claude/claude.exe"),
+            Path.home() / "AppData" / "Local" / "Programs" / "Claude" / "claude.exe",
+        ]
+    else:  # macOS and Linux
+        common_paths = [
+            Path("/opt/homebrew/bin/claude"),
+            Path("/usr/local/bin/claude"),
+            Path.home() / ".local/bin/claude",
+            Path.home() / "bin/claude",
+        ]
+
+    logger.debug(f"Checking {len(common_paths)} common paths")
+
+    for path in common_paths:
+        if verify_claude_executable(path):
+            logger.info(f"Found Claude CLI in common path: {path}")
+            return path
+        else:
+            logger.debug(f"Not found or invalid: {path}")
+
+    logger.debug("No Claude CLI found in common paths")
+    return None
+
+
+def detect_claude_cli() -> Optional[Path]:
+    """Main orchestrator for detecting Claude CLI.
+
+    Tries detection methods in priority order:
+    1. Cache
+    2. System PATH
+    3. Running processes
+    4. VSCode extensions
+    5. NPM global
+    6. Common paths
+
+    Returns:
+        Path to Claude CLI if found, None otherwise.
+    """
+    logger.debug("Starting Claude CLI auto-detection")
+
+    # Try cache first (fastest)
+    path = get_cached_path()
+    if path:
+        return path
+
+    # Try each detection method in order
+    detection_methods = [
+        ("System PATH", detect_from_path),
+        ("Running processes", detect_from_processes),
+        ("VSCode extensions", detect_from_vscode),
+        ("NPM global", detect_from_npm),
+        ("Common paths", detect_from_common_paths),
+    ]
+
+    for method_name, method_func in detection_methods:
+        logger.debug(f"Trying detection method: {method_name}")
+        path = method_func()
+        if path:
+            logger.info(f"Claude CLI detected via {method_name}: {path}")
+            return path
+
+    logger.error("Claude CLI not found by any detection method")
+    return None

{cli2api-0.2.0 → cli2api-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cli2api"
-version = "0.2.0"
+version = "0.2.1"
 description = "OpenAI-compatible API over Claude Code CLI"
 readme = "README.md"
 requires-python = ">=3.11"

cli2api-0.2.1/tests/test_cli_detector.py

@@ -0,0 +1,423 @@
+"""Tests for Claude CLI auto-detection."""
+
+import platform
+import subprocess
+from pathlib import Path
+from unittest.mock import MagicMock, Mock, patch
+
+import pytest
+
+from cli2api.utils.cli_detector import (
+    CACHE_FILE,
+    cache_path,
+    detect_claude_cli,
+    detect_from_common_paths,
+    detect_from_npm,
+    detect_from_path,
+    detect_from_processes,
+    detect_from_vscode,
+    get_cached_path,
+    get_vscode_extensions_dir,
+    verify_claude_executable,
+)
+
+
+class TestVerifyClaudeExecutable:
+    """Tests for verify_claude_executable function."""
+
+    def test_returns_false_for_nonexistent_path(self):
+        """Test that verify returns False for non-existent path."""
+        path = Path("/nonexistent/path/to/claude")
+        assert verify_claude_executable(path) is False
+
+    def test_returns_false_for_directory(self, tmp_path):
+        """Test that verify returns False for directory."""
+        dir_path = tmp_path / "claude"
+        dir_path.mkdir()
+        assert verify_claude_executable(dir_path) is False
+
+    def test_returns_false_for_non_executable(self, tmp_path):
+        """Test that verify returns False for non-executable file."""
+        file_path = tmp_path / "claude"
+        file_path.write_text("#!/bin/bash\necho 'test'")
+        file_path.chmod(0o644)  # Not executable
+        assert verify_claude_executable(file_path) is False
+
+    @patch("subprocess.run")
+    def test_returns_true_for_valid_executable(self, mock_run, tmp_path):
+        """Test that verify returns True for valid Claude executable."""
+        file_path = tmp_path / "claude"
+        file_path.write_text("#!/bin/bash\necho 'claude version 1.0'")
+        file_path.chmod(0o755)  # Make executable
+
+        # Mock successful --version check
+        mock_run.return_value = Mock(returncode=0)
+
+        assert verify_claude_executable(file_path) is True
+        mock_run.assert_called_once()
+
+    @patch("subprocess.run")
+    def test_returns_false_when_version_check_fails(self, mock_run, tmp_path):
+        """Test that verify returns False when --version fails."""
+        file_path = tmp_path / "claude"
+        file_path.write_text("#!/bin/bash\nexit 1")
+        file_path.chmod(0o755)
+
+        # Mock failed --version check
+        mock_run.return_value = Mock(returncode=1)
+
+        assert verify_claude_executable(file_path) is False
+
+    @patch("subprocess.run")
+    def test_handles_timeout_gracefully(self, mock_run, tmp_path):
+        """Test that verify handles timeout gracefully."""
+        file_path = tmp_path / "claude"
+        file_path.write_text("#!/bin/bash\nsleep 10")
+        file_path.chmod(0o755)
+
+        # Mock timeout
+        mock_run.side_effect = subprocess.TimeoutExpired("claude", 2)
+
+        assert verify_claude_executable(file_path) is False
+
+
+class TestCaching:
+    """Tests for path caching functionality."""
+
+    def test_get_cached_path_returns_none_when_no_cache(self, tmp_path, monkeypatch):
+        """Test that get_cached_path returns None when cache doesn't exist."""
+        # Use temporary cache location
+        cache_file = tmp_path / "cache" / "claude_cli_path"
+        monkeypatch.setattr("cli2api.utils.cli_detector.CACHE_FILE", cache_file)
+
+        assert get_cached_path() is None
+
+    @patch("cli2api.utils.cli_detector.verify_claude_executable")
+    def test_get_cached_path_returns_valid_path(self, mock_verify, tmp_path, monkeypatch):
+        """Test that get_cached_path returns valid cached path."""
+        cache_file = tmp_path / "cache" / "claude_cli_path"
+        cache_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write a path to cache
+        test_path = Path("/usr/local/bin/claude")
+        cache_file.write_text(str(test_path))
+
+        # Mock verification as successful
+        mock_verify.return_value = True
+
+        monkeypatch.setattr("cli2api.utils.cli_detector.CACHE_FILE", cache_file)
+
+        result = get_cached_path()
+        assert result == test_path
+        mock_verify.assert_called_once_with(test_path)
+
+    @patch("cli2api.utils.cli_detector.verify_claude_executable")
+    def test_get_cached_path_invalidates_bad_path(self, mock_verify, tmp_path, monkeypatch):
+        """Test that get_cached_path removes invalid cache."""
+        cache_file = tmp_path / "cache" / "claude_cli_path"
+        cache_file.parent.mkdir(parents=True, exist_ok=True)
+        cache_file.write_text("/invalid/path/claude")
+
+        # Mock verification as failed
+        mock_verify.return_value = False
+
+        monkeypatch.setattr("cli2api.utils.cli_detector.CACHE_FILE", cache_file)
+
+        result = get_cached_path()
+        assert result is None
+        assert not cache_file.exists()
+
+    def test_cache_path_creates_directory(self, tmp_path, monkeypatch):
+        """Test that cache_path creates cache directory."""
+        cache_file = tmp_path / "new_cache_dir" / "claude_cli_path"
+        monkeypatch.setattr("cli2api.utils.cli_detector.CACHE_FILE", cache_file)
+
+        test_path = Path("/usr/local/bin/claude")
+        cache_path(test_path)
+
+        assert cache_file.exists()
+        assert cache_file.read_text() == str(test_path)
+
+    def test_cache_path_handles_errors_gracefully(self, tmp_path, monkeypatch):
+        """Test that cache_path handles write errors gracefully."""
+        # Create a read-only directory
+        cache_dir = tmp_path / "readonly"
+        cache_dir.mkdir()
+        cache_file = cache_dir / "claude_cli_path"
+
+        # Make directory read-only
+        cache_dir.chmod(0o444)
+
+        monkeypatch.setattr("cli2api.utils.cli_detector.CACHE_FILE", cache_file)
+
+        test_path = Path("/usr/local/bin/claude")
+        # Should not raise exception
+        cache_path(test_path)
+
+        # Cleanup: restore permissions
+        cache_dir.chmod(0o755)
+
+
+class TestGetVSCodeExtensionsDir:
+    """Tests for get_vscode_extensions_dir function."""
+
+    @patch("platform.system")
+    def test_returns_windows_path(self, mock_system):
+        """Test that Windows path is returned on Windows."""
+        mock_system.return_value = "Windows"
+        result = get_vscode_extensions_dir()
+        assert "AppData" in str(result)
+        assert "Code" in str(result)
+        assert "extensions" in str(result)
+
+    @patch("platform.system")
+    def test_returns_unix_path(self, mock_system):
+        """Test that Unix path is returned on macOS/Linux."""
+        for system in ["Darwin", "Linux"]:
+            mock_system.return_value = system
+            result = get_vscode_extensions_dir()
+            assert ".vscode" in str(result)
+            assert "extensions" in str(result)
+
+
+class TestDetectFromPath:
+    """Tests for detect_from_path function."""
+
+    @patch("shutil.which")
+    @patch("cli2api.utils.cli_detector.verify_claude_executable")
+    def test_finds_claude_in_path(self, mock_verify, mock_which):
+        """Test that detect_from_path finds Claude in PATH."""
+        mock_which.return_value = "/usr/local/bin/claude"
+        mock_verify.return_value = True
+
+        result = detect_from_path()
+        assert result == Path("/usr/local/bin/claude")
+
+    @patch("shutil.which")
+    def test_returns_none_when_not_in_path(self, mock_which):
+        """Test that detect_from_path returns None when not in PATH."""
+        mock_which.return_value = None
+
+        result = detect_from_path()
+        assert result is None
+
+
+class TestDetectFromProcesses:
+    """Tests for detect_from_processes function."""
+
+    @patch("platform.system")
+    @patch("subprocess.run")
+    @patch("cli2api.utils.cli_detector.verify_claude_executable")
+    def test_detects_from_ps_aux_on_unix(self, mock_verify, mock_run, mock_system):
+        """Test detection from ps aux on Unix systems."""
+        mock_system.return_value = "Darwin"
+        mock_verify.return_value = True
+
+        # Mock ps aux output with Claude process
+        ps_output = """
+USER       PID  %CPU %MEM      VSZ    RSS   TT  STAT STARTED      TIME COMMAND
+user     12345   1.0  2.0  1234567 123456   ??  S    1:00PM   0:01.23 /path/to/vscode/native-binary/claude --args
+"""
+        mock_run.return_value = Mock(stdout=ps_output, returncode=0)
+
+        # Need to mock Path.exists() for the extracted path
+        with patch("pathlib.Path.exists", return_value=True):
+            result = detect_from_processes()
+            assert result == Path("/path/to/vscode/native-binary/claude")
+
+    @patch("platform.system")
+    @patch("subprocess.run")
+    def test_returns_none_when_no_processes_found(self, mock_run, mock_system):
+        """Test that returns None when no Claude processes found."""
+        mock_system.return_value = "Linux"
+        mock_run.return_value = Mock(stdout="no claude processes here", returncode=0)
+
+        result = detect_from_processes()
+        assert result is None
+
+    @patch("platform.system")
+    @patch("subprocess.run")
+    def test_handles_subprocess_timeout(self, mock_run, mock_system):
+        """Test that handles subprocess timeout gracefully."""
+        mock_system.return_value = "Darwin"
+        mock_run.side_effect = subprocess.TimeoutExpired("ps", 2)
+
+        result = detect_from_processes()
+        assert result is None
+
+
+class TestDetectFromVSCode:
+    """Tests for detect_from_vscode function."""
+
+    @patch("cli2api.utils.cli_detector.get_vscode_extensions_dir")
+    @patch("cli2api.utils.cli_detector.verify_claude_executable")
+    @patch("platform.system")
+    def test_finds_latest_version(self, mock_system, mock_verify, mock_vscode_dir, tmp_path):
+        """Test that detect_from_vscode finds latest version."""
+        mock_system.return_value = "Darwin"
+        mock_vscode_dir.return_value = tmp_path
+
+        # Create multiple version directories
+        ext1 = tmp_path / "anthropic.claude-code-2.1.27-darwin-arm64"
+        ext2 = tmp_path / "anthropic.claude-code-2.1.31-darwin-arm64"
+        ext3 = tmp_path / "anthropic.claude-code-2.1.29-darwin-arm64"
+
+        for ext_dir in [ext1, ext2, ext3]:
+            binary_path = ext_dir / "resources" / "native-binary"
+            binary_path.mkdir(parents=True)
+            (binary_path / "claude").touch()
+
+        # Verify should succeed for the latest version
+        def verify_side_effect(path):
+            return "2.1.31" in str(path)
+
+        mock_verify.side_effect = verify_side_effect
+
+        result = detect_from_vscode()
+        assert result is not None
+        assert "2.1.31" in str(result)
+
+    @patch("cli2api.utils.cli_detector.get_vscode_extensions_dir")
+    def test_returns_none_when_vscode_dir_not_found(self, mock_vscode_dir, tmp_path):
+        """Test that returns None when VSCode directory doesn't exist."""
+        mock_vscode_dir.return_value = tmp_path / "nonexistent"
+
+        result = detect_from_vscode()
+        assert result is None
+
+    @patch("cli2api.utils.cli_detector.get_vscode_extensions_dir")
+    @patch("platform.system")
+    def test_handles_windows_exe(self, mock_system, mock_vscode_dir, tmp_path):
+        """Test that handles .exe extension on Windows."""
+        mock_system.return_value = "Windows"
+        mock_vscode_dir.return_value = tmp_path
+
+        ext_dir = tmp_path / "anthropic.claude-code-2.1.31-win32-x64"
+        binary_path = ext_dir / "resources" / "native-binary"
+        binary_path.mkdir(parents=True)
+
+        # Windows should look for claude.exe
+        exe_file = binary_path / "claude.exe"
+        exe_file.touch()
+
+        with patch("cli2api.utils.cli_detector.verify_claude_executable", return_value=True):
+            result = detect_from_vscode()
+            assert result == exe_file
+
+
+class TestDetectFromNPM:
+    """Tests for detect_from_npm function."""
+
+    @patch("subprocess.run")
+    @patch("cli2api.utils.cli_detector.verify_claude_executable")
+    def test_finds_claude_in_npm_global(self, mock_verify, mock_run, tmp_path):
+        """Test that detect_from_npm finds Claude in npm global packages."""
+        npm_root = tmp_path / "npm_global"
+        npm_root.mkdir()
+
+        # Create package structure
+        package_dir = npm_root / "@anthropic-ai" / "claude-code"
+        bin_dir = package_dir / "bin"
+        bin_dir.mkdir(parents=True)
+        claude_bin = bin_dir / "claude"
+        claude_bin.touch()
+
+        # Mock npm root command
+        mock_run.return_value = Mock(stdout=str(npm_root), returncode=0)
+        mock_verify.return_value = True
+
+        result = detect_from_npm()
+        assert result == claude_bin
+
+    @patch("subprocess.run")
+    def test_returns_none_when_npm_fails(self, mock_run):
+        """Test that returns None when npm command fails."""
+        mock_run.side_effect = FileNotFoundError()
+
+        result = detect_from_npm()
+        assert result is None
+
+
+class TestDetectFromCommonPaths:
+    """Tests for detect_from_common_paths function."""
+
+    @patch("platform.system")
+    @patch("cli2api.utils.cli_detector.verify_claude_executable")
+    def test_checks_unix_paths(self, mock_verify, mock_system):
+        """Test that checks Unix common paths."""
+        mock_system.return_value = "Darwin"
+
+        def verify_side_effect(path):
+            return str(path) == "/opt/homebrew/bin/claude"
+
+        mock_verify.side_effect = verify_side_effect
+
+        result = detect_from_common_paths()
+        assert result == Path("/opt/homebrew/bin/claude")
+
+    @patch("platform.system")
+    @patch("cli2api.utils.cli_detector.verify_claude_executable")
+    def test_checks_windows_paths(self, mock_verify, mock_system):
+        """Test that checks Windows common paths."""
+        mock_system.return_value = "Windows"
+        mock_verify.return_value = False
+
+        result = detect_from_common_paths()
+        assert result is None
+
+
+class TestDetectClaudeCLI:
+    """Tests for main detect_claude_cli orchestrator."""
+
+    @patch("cli2api.utils.cli_detector.get_cached_path")
+    def test_uses_cache_first(self, mock_cache):
+        """Test that detect_claude_cli checks cache first."""
+        mock_cache.return_value = Path("/cached/claude")
+
+        result = detect_claude_cli()
+        assert result == Path("/cached/claude")
+
+    @patch("cli2api.utils.cli_detector.get_cached_path")
+    @patch("cli2api.utils.cli_detector.detect_from_path")
+    @patch("cli2api.utils.cli_detector.detect_from_processes")
+    @patch("cli2api.utils.cli_detector.detect_from_vscode")
+    def test_tries_methods_in_order(self, mock_vscode, mock_processes, mock_path, mock_cache):
+        """Test that detect_claude_cli tries methods in correct order."""
+        # Cache returns None
+        mock_cache.return_value = None
+        # PATH returns None
+        mock_path.return_value = None
+        # Processes returns None
+        mock_processes.return_value = None
+        # VSCode succeeds
+        mock_vscode.return_value = Path("/vscode/claude")
+
+        result = detect_claude_cli()
+        assert result == Path("/vscode/claude")
+
+        # Verify order of calls
+        mock_cache.assert_called_once()
+        mock_path.assert_called_once()
+        mock_processes.assert_called_once()
+        mock_vscode.assert_called_once()
+
+    @patch("cli2api.utils.cli_detector.get_cached_path")
+    @patch("cli2api.utils.cli_detector.detect_from_path")
+    @patch("cli2api.utils.cli_detector.detect_from_processes")
+    @patch("cli2api.utils.cli_detector.detect_from_vscode")
+    @patch("cli2api.utils.cli_detector.detect_from_npm")
+    @patch("cli2api.utils.cli_detector.detect_from_common_paths")
+    def test_returns_none_when_all_fail(
+        self, mock_common, mock_npm, mock_vscode, mock_processes, mock_path, mock_cache
+    ):
+        """Test that returns None when all detection methods fail."""
+        # All methods return None
+        mock_cache.return_value = None
+        mock_path.return_value = None
+        mock_processes.return_value = None
+        mock_vscode.return_value = None
+        mock_npm.return_value = None
+        mock_common.return_value = None
+
+        result = detect_claude_cli()
+        assert result is None

{cli2api-0.2.0 → cli2api-0.2.1}/tests/test_config.py

@@ -1,6 +1,7 @@
 """Tests for configuration and settings."""
 
 import os
+from pathlib import Path
 from unittest.mock import patch
 
 import pytest
@@ -54,15 +55,18 @@ class TestSettings:
             "CLI2API_CLAUDE_CLI_PATH": "/custom/path/to/claude",
         }
 
-        with patch.dict(os.environ, env_vars, clear=True):
-            settings = Settings(_env_file=None)
+        # Mock verify_claude_executable to accept the custom path
+        with patch("cli2api.utils.cli_detector.verify_claude_executable", return_value=True):
+            with patch.dict(os.environ, env_vars, clear=True):
+                settings = Settings(_env_file=None)
 
-            assert settings.claude_cli_path == "/custom/path/to/claude"
+                assert settings.claude_cli_path == "/custom/path/to/claude"
 
     def test_cli_path_auto_detect(self):
         """Test CLI path auto-detection."""
-        with patch("shutil.which") as mock_which:
-            mock_which.return_value = "/detected/path/to/claude"
+        # Mock detect_claude_cli to return a detected path
+        with patch("cli2api.utils.cli_detector.detect_claude_cli") as mock_detect:
+            mock_detect.return_value = Path("/detected/path/to/claude")
 
             with patch.dict(os.environ, {}, clear=True):
                 settings = Settings(_env_file=None)
@@ -71,12 +75,12 @@ class TestSettings:
 
     def test_cli_path_not_found(self):
         """Test when CLI is not found."""
-        with patch("cli2api.config.settings.shutil.which", return_value=None):
-            with patch("pathlib.Path.exists", return_value=False):
-                with patch.dict(os.environ, {}, clear=True):
-                    settings = Settings(_env_file=None)
+        # Mock detect_claude_cli to return None (not found)
+        with patch("cli2api.utils.cli_detector.detect_claude_cli", return_value=None):
+            with patch.dict(os.environ, {}, clear=True):
+                settings = Settings(_env_file=None)
 
-                    assert settings.claude_cli_path is None
+                assert settings.claude_cli_path is None
 
     def test_explicit_path_overrides_auto_detect(self):
         """Test that explicit path overrides auto-detection."""
@@ -84,11 +88,14 @@ class TestSettings:
             "CLI2API_CLAUDE_CLI_PATH": "/explicit/claude",
         }
 
-        with patch("shutil.which", return_value="/auto/detected"):
-            with patch.dict(os.environ, env_vars, clear=True):
-                settings = Settings(_env_file=None)
+        # Mock verify to accept explicit path
+        with patch("cli2api.utils.cli_detector.verify_claude_executable", return_value=True):
+            # Mock detect_claude_cli (should not be called when explicit path is valid)
+            with patch("cli2api.utils.cli_detector.detect_claude_cli", return_value=Path("/auto/detected")):
+                with patch.dict(os.environ, env_vars, clear=True):
+                    settings = Settings(_env_file=None)
 
-                assert settings.claude_cli_path == "/explicit/claude"
+                    assert settings.claude_cli_path == "/explicit/claude"
 
     def test_get_claude_models_default(self):
         """Test default Claude models."""

cli2api-0.2.0/.env.example

@@ -1,22 +0,0 @@
-# CLI2API Configuration
-# Copy this file to .env and customize as needed
-
-# Server settings
-CLI2API_HOST=0.0.0.0
-CLI2API_PORT=8000
-CLI2API_DEBUG=false
-
-# CLI executable path (auto-detected if not set)
-# CLI2API_CLAUDE_CLI_PATH=/opt/homebrew/bin/claude
-
-# Timeout (in seconds)
-CLI2API_DEFAULT_TIMEOUT=300
-
-# Default model
-CLI2API_DEFAULT_MODEL=sonnet
-
-# Custom models (comma-separated)
-# CLI2API_CLAUDE_MODELS=sonnet,opus,haiku
-
-# Logging
-CLI2API_LOG_LEVEL=INFO