ccproxy-api 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

ccproxy/utils/startup_helpers.py

@@ -15,6 +15,7 @@ from fastapi import FastAPI
 
 from ccproxy.auth.credentials_adapter import CredentialsAuthManager
 from ccproxy.auth.exceptions import CredentialsNotFoundError
+from ccproxy.auth.openai.credentials import OpenAITokenManager
 from ccproxy.observability import get_metrics
 
 # Note: get_claude_cli_info is imported locally to avoid circular imports
@@ -23,6 +24,7 @@ from ccproxy.scheduler.errors import SchedulerError
 from ccproxy.scheduler.manager import start_scheduler, stop_scheduler
 from ccproxy.services.claude_detection_service import ClaudeDetectionService
 from ccproxy.services.claude_sdk_service import ClaudeSDKService
+from ccproxy.services.codex_detection_service import CodexDetectionService
 from ccproxy.services.credentials.manager import CredentialsManager
 
 
@@ -34,8 +36,10 @@ if TYPE_CHECKING:
 logger = structlog.get_logger(__name__)
 
 
-async def validate_authentication_startup(app: FastAPI, settings: Settings) -> None:
-    """Validate authentication credentials at startup.
+async def validate_claude_authentication_startup(
+    app: FastAPI, settings: Settings
+) -> None:
+    """Validate Claude authentication credentials at startup.
 
     Args:
         app: FastAPI application instance
@@ -57,40 +61,145 @@ async def validate_authentication_startup(app: FastAPI, settings: Settings) -> N
                     / 3600
                 )
                 logger.debug(
-                    "auth_token_valid",
+                    "claude_token_valid",
                     expires_in_hours=hours_until_expiry,
                     subscription_type=oauth_token.subscription_type,
                     credentials_path=str(validation.path) if validation.path else None,
                 )
             else:
-                logger.debug("auth_token_valid", credentials_path=str(validation.path))
+                logger.debug(
+                    "claude_token_valid", credentials_path=str(validation.path)
+                )
         elif validation.expired:
             logger.warning(
-                "auth_token_expired",
-                message="Authentication token has expired. Please run 'ccproxy auth login' to refresh.",
+                "claude_token_expired",
+                message="Claude authentication token has expired. Please run 'ccproxy auth login' to refresh.",
                 credentials_path=str(validation.path) if validation.path else None,
             )
         else:
             logger.warning(
-                "auth_token_invalid",
-                message="Authentication token is invalid. Please run 'ccproxy auth login'.",
+                "claude_token_invalid",
+                message="Claude authentication token is invalid. Please run 'ccproxy auth login'.",
                 credentials_path=str(validation.path) if validation.path else None,
             )
     except CredentialsNotFoundError:
         logger.warning(
-            "auth_token_not_found",
-            message="No authentication credentials found. Please run 'ccproxy auth login' to authenticate.",
+            "claude_token_not_found",
+            message="No Claude authentication credentials found. Please run 'ccproxy auth login' to authenticate.",
             searched_paths=settings.auth.storage.storage_paths,
         )
     except Exception as e:
         logger.error(
-            "auth_token_validation_error",
+            "claude_token_validation_error",
             error=str(e),
-            message="Failed to validate authentication token. The server will continue without authentication.",
+            message="Failed to validate Claude authentication token. The server will continue without Claude authentication.",
             exc_info=True,
         )
 
 
+async def validate_codex_authentication_startup(
+    app: FastAPI, settings: Settings
+) -> None:
+    """Validate Codex (OpenAI) authentication credentials at startup.
+
+    Args:
+        app: FastAPI application instance
+        settings: Application settings
+    """
+    # Skip codex authentication validation if codex is disabled
+    if not settings.codex.enabled:
+        logger.debug("codex_token_validation_skipped", reason="codex_disabled")
+        return
+
+    try:
+        token_manager = OpenAITokenManager()
+        credentials = await token_manager.load_credentials()
+
+        if not credentials:
+            logger.warning(
+                "codex_token_not_found",
+                message="No Codex authentication credentials found. Please run 'ccproxy auth login-openai' to authenticate.",
+                location=token_manager.get_storage_location(),
+            )
+            return
+
+        if not credentials.active:
+            logger.warning(
+                "codex_token_inactive",
+                message="Codex authentication credentials are inactive. Please run 'ccproxy auth login-openai' to refresh.",
+                location=token_manager.get_storage_location(),
+            )
+            return
+
+        if credentials.is_expired():
+            logger.warning(
+                "codex_token_expired",
+                message="Codex authentication token has expired. Please run 'ccproxy auth login-openai' to refresh.",
+                location=token_manager.get_storage_location(),
+                expires_at=credentials.expires_at.isoformat(),
+            )
+        else:
+            hours_until_expiry = int(credentials.expires_in_seconds() / 3600)
+            logger.debug(
+                "codex_token_valid",
+                expires_in_hours=hours_until_expiry,
+                account_id=credentials.account_id,
+                location=token_manager.get_storage_location(),
+            )
+
+    except Exception as e:
+        logger.error(
+            "codex_token_validation_error",
+            error=str(e),
+            message="Failed to validate Codex authentication token. The server will continue without Codex authentication.",
+            exc_info=True,
+        )
+
+
+async def check_version_updates_startup(app: FastAPI, settings: Settings) -> None:
+    """Trigger version update check at startup.
+
+    Manually runs the version check task once during application startup,
+    before the scheduler starts managing periodic checks.
+
+    Args:
+        app: FastAPI application instance
+        settings: Application settings
+    """
+    # Skip version check if disabled by settings
+    if not settings.scheduler.version_check_enabled:
+        logger.debug("version_check_startup_disabled")
+        return
+
+    try:
+        # Import locally to avoid circular imports and create task instance
+        from ccproxy.scheduler.tasks import VersionUpdateCheckTask
+
+        # Create a temporary task instance for startup check
+        version_task = VersionUpdateCheckTask(
+            name="version_check_startup",
+            interval_seconds=settings.scheduler.version_check_interval_hours * 3600,
+            enabled=True,
+            version_check_cache_ttl_hours=settings.scheduler.version_check_cache_ttl_hours,
+            skip_first_scheduled_run=False,
+        )
+
+        # Run the version check once and wait for it to complete
+        success = await version_task.run()
+
+        if success:
+            logger.debug("version_check_startup_completed")
+        else:
+            logger.debug("version_check_startup_failed")
+
+    except Exception as e:
+        logger.debug(
+            "version_check_startup_error",
+            error=str(e),
+            error_type=type(e).__name__,
+        )
+
+
 async def check_claude_cli_startup(app: FastAPI, settings: Settings) -> None:
     """Check Claude CLI availability at startup.
 
@@ -126,6 +235,41 @@ async def check_claude_cli_startup(app: FastAPI, settings: Settings) -> None:
         )
 
 
+async def check_codex_cli_startup(app: FastAPI, settings: Settings) -> None:
+    """Check Codex CLI availability at startup.
+
+    Args:
+        app: FastAPI application instance
+        settings: Application settings
+    """
+    try:
+        from ccproxy.api.routes.health import get_codex_cli_info
+
+        codex_info = await get_codex_cli_info()
+
+        if codex_info.status == "available":
+            logger.info(
+                "codex_cli_available",
+                status=codex_info.status,
+                version=codex_info.version,
+                binary_path=codex_info.binary_path,
+            )
+        else:
+            logger.warning(
+                "codex_cli_unavailable",
+                status=codex_info.status,
+                error=codex_info.error,
+                binary_path=codex_info.binary_path,
+                message=f"Codex CLI status: {codex_info.status}",
+            )
+    except Exception as e:
+        logger.error(
+            "codex_cli_check_failed",
+            error=str(e),
+            message="Failed to check Codex CLI status during startup",
+        )
+
+
 async def initialize_log_storage_startup(app: FastAPI, settings: Settings) -> None:
     """Initialize log storage if needed and backend is DuckDB.
 
@@ -261,6 +405,55 @@ async def initialize_claude_detection_startup(app: FastAPI, settings: Settings)
         app.state.claude_detection_service = detection_service
 
 
+async def initialize_codex_detection_startup(app: FastAPI, settings: Settings) -> None:
+    """Initialize Codex detection service.
+
+    Args:
+        app: FastAPI application instance
+        settings: Application settings
+    """
+    # Skip codex detection if codex is disabled
+    if not settings.codex.enabled:
+        logger.debug("codex_detection_skipped", reason="codex_disabled")
+        detection_service = CodexDetectionService(settings)
+        app.state.codex_detection_data = detection_service._get_fallback_data()
+        app.state.codex_detection_service = detection_service
+        return
+
+    # Check if Codex CLI is available before attempting header detection
+    from ccproxy.api.routes.health import get_codex_cli_info
+
+    codex_info = await get_codex_cli_info()
+    if codex_info.status != "available":
+        logger.debug(
+            "codex_detection_skipped",
+            reason="codex_cli_not_available",
+            status=codex_info.status,
+        )
+        detection_service = CodexDetectionService(settings)
+        app.state.codex_detection_data = detection_service._get_fallback_data()
+        app.state.codex_detection_service = detection_service
+        return
+
+    try:
+        logger.debug("initializing_codex_detection")
+        detection_service = CodexDetectionService(settings)
+        codex_data = await detection_service.initialize_detection()
+        app.state.codex_detection_data = codex_data
+        app.state.codex_detection_service = detection_service
+        logger.debug(
+            "codex_detection_completed",
+            version=codex_data.codex_version,
+            cached_at=codex_data.cached_at.isoformat(),
+        )
+    except Exception as e:
+        logger.error("codex_detection_startup_failed", error=str(e))
+        # Continue startup with fallback - detection service will provide fallback data
+        detection_service = CodexDetectionService(settings)
+        app.state.codex_detection_data = detection_service._get_fallback_data()
+        app.state.codex_detection_service = detection_service
+
+
 async def initialize_claude_sdk_startup(app: FastAPI, settings: Settings) -> None:
     """Initialize ClaudeSDKService and store in app state.
 

ccproxy/utils/version_checker.py

@@ -94,6 +94,12 @@ def compare_versions(current: str, latest: str) -> bool:
     try:
         current_parsed = pkg_version.parse(current)
         latest_parsed = pkg_version.parse(latest)
+
+        # For dev versions, compare base version instead
+        if current_parsed.is_devrelease:
+            current_base = pkg_version.parse(current_parsed.base_version)
+            return latest_parsed > current_base
+
         return latest_parsed > current_parsed
     except Exception as e:
         logger.error(