PyPI - klaude-code - Versions diffs - 2.6.0__py3-none-any.whl → 2.8.0__py3-none-any.whl - Mend

klaude-code 2.6.0py3-none-any.whl → 2.8.0py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (82) hide show

klaude_code/app/runtime.py +1 -1
klaude_code/auth/AGENTS.md +325 -0
klaude_code/auth/__init__.py +17 -1
klaude_code/auth/antigravity/__init__.py +20 -0
klaude_code/auth/antigravity/exceptions.py +17 -0
klaude_code/auth/antigravity/oauth.py +320 -0
klaude_code/auth/antigravity/pkce.py +25 -0
klaude_code/auth/antigravity/token_manager.py +45 -0
klaude_code/auth/base.py +4 -0
klaude_code/auth/claude/oauth.py +29 -9
klaude_code/auth/codex/exceptions.py +4 -0
klaude_code/auth/env.py +19 -15
klaude_code/cli/auth_cmd.py +54 -4
klaude_code/cli/cost_cmd.py +83 -160
klaude_code/cli/list_model.py +50 -0
klaude_code/cli/main.py +99 -9
klaude_code/config/assets/builtin_config.yaml +108 -0
klaude_code/config/builtin_config.py +5 -11
klaude_code/config/config.py +24 -10
klaude_code/const.py +11 -1
klaude_code/core/agent.py +5 -1
klaude_code/core/agent_profile.py +28 -32
klaude_code/core/compaction/AGENTS.md +112 -0
klaude_code/core/compaction/__init__.py +11 -0
klaude_code/core/compaction/compaction.py +707 -0
klaude_code/core/compaction/overflow.py +30 -0
klaude_code/core/compaction/prompts.py +97 -0
klaude_code/core/executor.py +103 -2
klaude_code/core/manager/llm_clients.py +5 -0
klaude_code/core/manager/llm_clients_builder.py +14 -2
klaude_code/core/prompts/prompt-antigravity.md +80 -0
klaude_code/core/prompts/prompt-codex-gpt-5-2.md +335 -0
klaude_code/core/reminders.py +11 -7
klaude_code/core/task.py +126 -0
klaude_code/core/tool/todo/todo_write_tool.py +1 -1
klaude_code/core/turn.py +3 -1
klaude_code/llm/antigravity/__init__.py +3 -0
klaude_code/llm/antigravity/client.py +558 -0
klaude_code/llm/antigravity/input.py +261 -0
klaude_code/llm/registry.py +1 -0
klaude_code/protocol/commands.py +0 -1
klaude_code/protocol/events.py +18 -0
klaude_code/protocol/llm_param.py +1 -0
klaude_code/protocol/message.py +23 -1
klaude_code/protocol/op.py +15 -1
klaude_code/protocol/op_handler.py +5 -0
klaude_code/session/session.py +36 -0
klaude_code/skill/assets/create-plan/SKILL.md +6 -6
klaude_code/skill/loader.py +12 -13
klaude_code/skill/manager.py +3 -3
klaude_code/tui/command/__init__.py +4 -4
klaude_code/tui/command/compact_cmd.py +32 -0
klaude_code/tui/command/copy_cmd.py +1 -1
klaude_code/tui/command/fork_session_cmd.py +114 -18
klaude_code/tui/command/model_picker.py +5 -1
klaude_code/tui/command/thinking_cmd.py +1 -1
klaude_code/tui/commands.py +6 -0
klaude_code/tui/components/command_output.py +1 -1
klaude_code/tui/components/rich/markdown.py +117 -1
klaude_code/tui/components/rich/theme.py +18 -2
klaude_code/tui/components/tools.py +39 -25
klaude_code/tui/components/user_input.py +39 -28
klaude_code/tui/input/AGENTS.md +44 -0
klaude_code/tui/input/__init__.py +5 -2
klaude_code/tui/input/completers.py +10 -14
klaude_code/tui/input/drag_drop.py +146 -0
klaude_code/tui/input/images.py +227 -0
klaude_code/tui/input/key_bindings.py +183 -19
klaude_code/tui/input/paste.py +71 -0
klaude_code/tui/input/prompt_toolkit.py +32 -9
klaude_code/tui/machine.py +26 -1
klaude_code/tui/renderer.py +67 -4
klaude_code/tui/runner.py +19 -3
klaude_code/tui/terminal/image.py +103 -10
klaude_code/tui/terminal/selector.py +81 -7
{klaude_code-2.6.0.dist-info → klaude_code-2.8.0.dist-info}/METADATA +10 -10
{klaude_code-2.6.0.dist-info → klaude_code-2.8.0.dist-info}/RECORD +79 -61
klaude_code/core/prompts/prompt-codex-gpt-5-1-codex-max.md +0 -117
klaude_code/tui/command/terminal_setup_cmd.py +0 -248
klaude_code/tui/input/clipboard.py +0 -152
{klaude_code-2.6.0.dist-info → klaude_code-2.8.0.dist-info}/WHEEL +0 -0
{klaude_code-2.6.0.dist-info → klaude_code-2.8.0.dist-info}/entry_points.txt +0 -0

klaude_code/auth/antigravity/oauth.py ADDED Viewed

@@ -0,0 +1,320 @@
+"""OAuth PKCE flow for Antigravity authentication."""
+import base64
+import json
+import secrets
+import time
+import webbrowser
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from threading import Thread
+from typing import Any, cast
+from urllib.parse import parse_qs, urlencode, urlparse
+import httpx
+from klaude_code.auth.antigravity.exceptions import (
+    AntigravityNotLoggedInError,
+    AntigravityOAuthError,
+    AntigravityTokenExpiredError,
+)
+from klaude_code.auth.antigravity.pkce import generate_pkce
+from klaude_code.auth.antigravity.token_manager import AntigravityAuthState, AntigravityTokenManager
+# OAuth configuration (decoded from base64 for compatibility with pi implementation)
+CLIENT_ID = base64.b64decode(
+    "MTA3MTAwNjA2MDU5MS10bWhzc2luMmgyMWxjcmUyMzV2dG9sb2poNGc0MDNlcC5hcHBzLmdvb2dsZXVzZXJjb250ZW50LmNvbQ=="
+).decode()
+CLIENT_SECRET = base64.b64decode("R09DU1BYLUs1OEZXUjQ4NkxkTEoxbUxCOHNYQzR6NnFEQWY=").decode()
+REDIRECT_URI = "http://localhost:51121/oauth-callback"
+REDIRECT_PORT = 51121
+# Google OAuth endpoints
+AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth"
+TOKEN_URL = "https://oauth2.googleapis.com/token"
+# Antigravity requires additional scopes
+SCOPES = [
+    "https://www.googleapis.com/auth/cloud-platform",
+    "https://www.googleapis.com/auth/userinfo.email",
+    "https://www.googleapis.com/auth/userinfo.profile",
+    "https://www.googleapis.com/auth/cclog",
+    "https://www.googleapis.com/auth/experimentsandconfigs",
+]
+# Fallback project ID when discovery fails
+DEFAULT_PROJECT_ID = "rising-fact-p41fc"
+# Cloud Code Assist endpoint
+CLOUDCODE_ENDPOINT = "https://cloudcode-pa.googleapis.com"
+class OAuthCallbackHandler(BaseHTTPRequestHandler):
+    """HTTP request handler for OAuth callback."""
+    code: str | None = None
+    state: str | None = None
+    error: str | None = None
+    def log_message(self, format: str, *args: Any) -> None:
+        """Suppress HTTP server logs."""
+        pass
+    def do_GET(self) -> None:
+        """Handle GET request from OAuth callback."""
+        parsed = urlparse(self.path)
+        params = parse_qs(parsed.query)
+        OAuthCallbackHandler.code = params.get("code", [None])[0]
+        OAuthCallbackHandler.state = params.get("state", [None])[0]
+        OAuthCallbackHandler.error = params.get("error", [None])[0]
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html")
+        self.end_headers()
+        if OAuthCallbackHandler.error:
+            html = f"""
+            <html><body style="font-family: sans-serif; text-align: center; padding: 50px;">
+            <h1>Authentication Failed</h1>
+            <p>Error: {OAuthCallbackHandler.error}</p>
+            <p>Please close this window and try again.</p>
+            </body></html>
+            """
+        else:
+            html = """
+            <html><body style="font-family: sans-serif; text-align: center; padding: 50px;">
+            <h1>Authentication Successful!</h1>
+            <p>You can close this window now.</p>
+            <script>setTimeout(function() { window.close(); }, 2000);</script>
+            </body></html>
+            """
+        self.wfile.write(html.encode())
+def _discover_project(access_token: str) -> str:
+    """Discover or provision a project for the user."""
+    headers = {
+        "Authorization": f"Bearer {access_token}",
+        "Content-Type": "application/json",
+        "User-Agent": "google-api-nodejs-client/9.15.1",
+        "X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
+        "Client-Metadata": json.dumps(
+            {
+                "ideType": "IDE_UNSPECIFIED",
+                "platform": "PLATFORM_UNSPECIFIED",
+                "pluginType": "GEMINI",
+            }
+        ),
+    }
+    try:
+        with httpx.Client() as client:
+            response = client.post(
+                f"{CLOUDCODE_ENDPOINT}/v1internal:loadCodeAssist",
+                headers=headers,
+                json={
+                    "metadata": {
+                        "ideType": "IDE_UNSPECIFIED",
+                        "platform": "PLATFORM_UNSPECIFIED",
+                        "pluginType": "GEMINI",
+                    },
+                },
+                timeout=30,
+            )
+            if response.status_code == 200:
+                data: dict[str, Any] = response.json()
+                project = data.get("cloudaicompanionProject")
+                if isinstance(project, str) and project:
+                    return project
+                if isinstance(project, dict):
+                    project_dict = cast(dict[str, Any], project)
+                    project_id = project_dict.get("id")
+                    if isinstance(project_id, str) and project_id:
+                        return project_id
+    except Exception:
+        pass
+    return DEFAULT_PROJECT_ID
+def _get_user_email(access_token: str) -> str | None:
+    """Get user email from the access token."""
+    try:
+        with httpx.Client() as client:
+            response = client.get(
+                "https://www.googleapis.com/oauth2/v1/userinfo?alt=json",
+                headers={"Authorization": f"Bearer {access_token}"},
+                timeout=10,
+            )
+            if response.status_code == 200:
+                data = response.json()
+                return data.get("email")
+    except Exception:
+        pass
+    return None
+class AntigravityOAuth:
+    """Handle OAuth PKCE flow for Antigravity authentication."""
+    def __init__(self, token_manager: AntigravityTokenManager | None = None):
+        self.token_manager = token_manager or AntigravityTokenManager()
+    def login(self) -> AntigravityAuthState:
+        """Run the complete OAuth login flow."""
+        verifier, challenge = generate_pkce()
+        state = secrets.token_urlsafe(32)
+        # Build authorization URL
+        auth_params = {
+            "client_id": CLIENT_ID,
+            "response_type": "code",
+            "redirect_uri": REDIRECT_URI,
+            "scope": " ".join(SCOPES),
+            "code_challenge": challenge,
+            "code_challenge_method": "S256",
+            "state": state,
+            "access_type": "offline",
+            "prompt": "consent",
+        }
+        auth_url = f"{AUTH_URL}?{urlencode(auth_params)}"
+        # Reset callback handler state
+        OAuthCallbackHandler.code = None
+        OAuthCallbackHandler.state = None
+        OAuthCallbackHandler.error = None
+        # Start callback server
+        server = HTTPServer(("localhost", REDIRECT_PORT), OAuthCallbackHandler)
+        server_thread = Thread(target=server.handle_request)
+        server_thread.start()
+        # Open browser for user to authenticate
+        webbrowser.open(auth_url)
+        # Wait for callback
+        server_thread.join(timeout=300)  # 5 minute timeout
+        server.server_close()
+        # Check for errors
+        if OAuthCallbackHandler.error:
+            raise AntigravityOAuthError(f"OAuth error: {OAuthCallbackHandler.error}")
+        if not OAuthCallbackHandler.code:
+            raise AntigravityOAuthError("No authorization code received")
+        if OAuthCallbackHandler.state is None or OAuthCallbackHandler.state != state:
+            raise AntigravityOAuthError("OAuth state mismatch")
+        # Exchange code for tokens
+        auth_state = self._exchange_code(OAuthCallbackHandler.code, verifier)
+        # Save tokens
+        self.token_manager.save(auth_state)
+        return auth_state
+    def _exchange_code(self, code: str, verifier: str) -> AntigravityAuthState:
+        """Exchange authorization code for tokens."""
+        data = {
+            "client_id": CLIENT_ID,
+            "client_secret": CLIENT_SECRET,
+            "code": code,
+            "grant_type": "authorization_code",
+            "redirect_uri": REDIRECT_URI,
+            "code_verifier": verifier,
+        }
+        with httpx.Client() as client:
+            response = client.post(TOKEN_URL, data=data, timeout=30)
+        if response.status_code != 200:
+            raise AntigravityOAuthError(f"Token exchange failed: {response.text}")
+        tokens = response.json()
+        access_token = tokens["access_token"]
+        refresh_token = tokens.get("refresh_token")
+        expires_in = tokens.get("expires_in", 3600)
+        if not refresh_token:
+            raise AntigravityOAuthError("No refresh token received. Please try again.")
+        # Get user email
+        email = _get_user_email(access_token)
+        # Discover project
+        project_id = _discover_project(access_token)
+        # Calculate expiry time with 5 minute buffer
+        expires_at = int(time.time()) + expires_in - 300
+        return AntigravityAuthState(
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at,
+            project_id=project_id,
+            email=email,
+        )
+    def refresh(self) -> AntigravityAuthState:
+        """Refresh the access token using refresh token."""
+        state = self.token_manager.get_state()
+        if state is None:
+            raise AntigravityNotLoggedInError("Not logged in to Antigravity. Run 'klaude login antigravity' first.")
+        data = {
+            "client_id": CLIENT_ID,
+            "client_secret": CLIENT_SECRET,
+            "refresh_token": state.refresh_token,
+            "grant_type": "refresh_token",
+        }
+        with httpx.Client() as client:
+            response = client.post(TOKEN_URL, data=data, timeout=30)
+        if response.status_code != 200:
+            raise AntigravityTokenExpiredError(f"Token refresh failed: {response.text}")
+        tokens = response.json()
+        access_token = tokens["access_token"]
+        refresh_token = tokens.get("refresh_token", state.refresh_token)
+        expires_in = tokens.get("expires_in", 3600)
+        # Calculate expiry time with 5 minute buffer
+        expires_at = int(time.time()) + expires_in - 300
+        new_state = AntigravityAuthState(
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at,
+            project_id=state.project_id,
+            email=state.email,
+        )
+        self.token_manager.save(new_state)
+        return new_state
+    def ensure_valid_token(self) -> tuple[str, str]:
+        """Ensure we have a valid access token, refreshing if needed.
+        Returns:
+            Tuple of (access_token, project_id).
+        """
+        state = self.token_manager.get_state()
+        if state is None:
+            raise AntigravityNotLoggedInError("Not logged in to Antigravity. Run 'klaude login antigravity' first.")
+        if state.is_expired():
+            state = self.refresh()
+        return state.access_token, state.project_id
+    def get_api_key_json(self) -> str:
+        """Get API key as JSON string for LLM client.
+        Returns:
+            JSON string with token and projectId.
+        """
+        access_token, project_id = self.ensure_valid_token()
+        return json.dumps({"token": access_token, "projectId": project_id})

klaude_code/auth/antigravity/pkce.py ADDED Viewed

@@ -0,0 +1,25 @@
+"""PKCE utilities for Antigravity OAuth."""
+import base64
+import hashlib
+import secrets
+def base64url_encode(data: bytes) -> str:
+    """Encode bytes as base64url string without padding."""
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+def generate_pkce() -> tuple[str, str]:
+    """Generate PKCE code verifier and challenge.
+    Returns:
+        Tuple of (verifier, challenge).
+    """
+    verifier_bytes = secrets.token_bytes(32)
+    verifier = base64url_encode(verifier_bytes)
+    challenge_hash = hashlib.sha256(verifier.encode("ascii")).digest()
+    challenge = base64url_encode(challenge_hash)
+    return verifier, challenge

klaude_code/auth/antigravity/token_manager.py ADDED Viewed

@@ -0,0 +1,45 @@
+"""Token storage and management for Antigravity authentication."""
+from pathlib import Path
+from typing import Any
+from klaude_code.auth.base import BaseAuthState, BaseTokenManager
+class AntigravityAuthState(BaseAuthState):
+    """Stored authentication state for Antigravity."""
+    project_id: str
+    email: str | None = None
+class AntigravityTokenManager(BaseTokenManager[AntigravityAuthState]):
+    """Manage Antigravity OAuth tokens."""
+    def __init__(self, auth_file: Path | None = None):
+        super().__init__(auth_file)
+    @property
+    def storage_key(self) -> str:
+        return "antigravity"
+    def _create_state(self, data: dict[str, Any]) -> AntigravityAuthState:
+        return AntigravityAuthState.model_validate(data)
+    def get_access_token(self) -> str:
+        """Get access token, raising if not logged in."""
+        state = self.get_state()
+        if state is None:
+            from klaude_code.auth.antigravity.exceptions import AntigravityNotLoggedInError
+            raise AntigravityNotLoggedInError("Not logged in to Antigravity. Run 'klaude login antigravity' first.")
+        return state.access_token
+    def get_project_id(self) -> str:
+        """Get project ID, raising if not logged in."""
+        state = self.get_state()
+        if state is None:
+            from klaude_code.auth.antigravity.exceptions import AntigravityNotLoggedInError
+            raise AntigravityNotLoggedInError("Not logged in to Antigravity. Run 'klaude login antigravity' first.")
+        return state.project_id

klaude_code/auth/base.py CHANGED Viewed

@@ -95,3 +95,7 @@ class BaseTokenManager[T: BaseAuthState](ABC):
         if self._state is None:
             self._state = self.load()
         return self._state
+    def clear_cached_state(self) -> None:
+        """Clear in-memory cached state to force reload from file on next access."""
+        self._state = None

klaude_code/auth/claude/oauth.py CHANGED Viewed

@@ -125,25 +125,45 @@ class ClaudeOAuth:
             expires_at=int(time.time()) + int(expires_in),
         )
-    def refresh(self) -> ClaudeAuthState:
-        """Refresh the access token using refresh token."""
-        state = self.token_manager.get_state()
-        if state is None:
-            raise ClaudeNotLoggedInError("Not logged in to Claude. Run 'klaude login claude' first.")
+    def _do_refresh_request(self, refresh_token: str) -> httpx.Response:
+        """Send token refresh request to OAuth server."""
         payload = {
             "grant_type": "refresh_token",
             "client_id": CLIENT_ID,
-            "refresh_token": state.refresh_token,
+            "refresh_token": refresh_token,
         }
         with httpx.Client() as client:
-            response = client.post(
+            return client.post(
                 TOKEN_URL,
                 json=payload,
                 headers={"Content-Type": "application/json"},
             )
+    def refresh(self) -> ClaudeAuthState:
+        """Refresh the access token using refresh token.
+        Handles concurrent refresh race conditions by retrying with freshly loaded token
+        if the first attempt fails with invalid_grant error.
+        """
+        state = self.token_manager.get_state()
+        if state is None:
+            raise ClaudeNotLoggedInError("Not logged in to Claude. Run 'klaude login claude' first.")
+        response = self._do_refresh_request(state.refresh_token)
+        # Handle race condition: another process may have refreshed the token already
+        if response.status_code != 200 and "invalid_grant" in response.text:
+            # Reload token from file (another process may have updated it)
+            self.token_manager.clear_cached_state()
+            fresh_state = self.token_manager.load()
+            if fresh_state and fresh_state.refresh_token != state.refresh_token:
+                # Token was updated by another process
+                if not fresh_state.is_expired():
+                    # New token is still valid, use it directly
+                    return fresh_state
+                # New token expired, try refreshing with the new refresh_token
+                response = self._do_refresh_request(fresh_state.refresh_token)
         if response.status_code != 200:
             raise ClaudeAuthError(f"Token refresh failed: {response.text}")

klaude_code/auth/codex/exceptions.py CHANGED Viewed

@@ -15,3 +15,7 @@ class CodexTokenExpiredError(CodexAuthError):
 class CodexOAuthError(CodexAuthError):
     """OAuth flow failed."""
+class CodexUnsupportedModelError(CodexAuthError):
+    """Model is not supported by codex_oauth protocol."""

klaude_code/auth/env.py CHANGED Viewed

@@ -1,7 +1,7 @@
 """Environment variable configuration stored in klaude-auth.json."""
 import json
-from typing import Any
+from typing import Any, cast
 from klaude_code.auth.base import KLAUDE_AUTH_FILE
@@ -11,9 +11,9 @@ def _load_store() -> dict[str, Any]:
     if not KLAUDE_AUTH_FILE.exists():
         return {}
     try:
-        data: Any = json.loads(KLAUDE_AUTH_FILE.read_text())
+        data = json.loads(KLAUDE_AUTH_FILE.read_text())
         if isinstance(data, dict):
-            return dict(data)
+            return cast(dict[str, Any], data)
         return {}
     except (json.JSONDecodeError, ValueError):
         return {}
@@ -25,26 +25,31 @@ def _save_store(data: dict[str, Any]) -> None:
     KLAUDE_AUTH_FILE.write_text(json.dumps(data, indent=2))
+def _get_env_section(store: dict[str, Any]) -> dict[str, Any] | None:
+    """Extract and validate the 'env' section from store."""
+    env_section = store.get("env")
+    if isinstance(env_section, dict):
+        return cast(dict[str, Any], env_section)
+    return None
 def get_auth_env(env_var: str) -> str | None:
     """Get environment variable value from klaude-auth.json 'env' section.
     This provides a fallback for API keys when real environment variables are not set.
     Priority: os.environ > klaude-auth.json env
     """
-    store = _load_store()
-    env_section: Any = store.get("env")
-    if not isinstance(env_section, dict):
+    env_section = _get_env_section(_load_store())
+    if env_section is None:
         return None
-    value: Any = env_section.get(env_var)
+    value = env_section.get(env_var)
     return str(value) if value is not None else None
 def set_auth_env(env_var: str, value: str) -> None:
     """Set environment variable value in klaude-auth.json 'env' section."""
     store = _load_store()
-    env_section: Any = store.get("env")
-    if not isinstance(env_section, dict):
-        env_section = {}
+    env_section = _get_env_section(store) or {}
     env_section[env_var] = value
     store["env"] = env_section
     _save_store(store)
@@ -53,8 +58,8 @@ def set_auth_env(env_var: str, value: str) -> None:
 def delete_auth_env(env_var: str) -> None:
     """Delete environment variable from klaude-auth.json 'env' section."""
     store = _load_store()
-    env_section: Any = store.get("env")
-    if not isinstance(env_section, dict):
+    env_section = _get_env_section(store)
+    if env_section is None:
         return
     env_section.pop(env_var, None)
     if len(env_section) == 0:
@@ -70,8 +75,7 @@ def delete_auth_env(env_var: str) -> None:
 def list_auth_env() -> dict[str, str]:
     """List all environment variables in klaude-auth.json 'env' section."""
-    store = _load_store()
-    env_section: Any = store.get("env")
-    if not isinstance(env_section, dict):
+    env_section = _get_env_section(_load_store())
+    if env_section is None:
         return {}
     return {k: str(v) for k, v in env_section.items() if v is not None}

klaude_code/cli/auth_cmd.py CHANGED Viewed

@@ -24,6 +24,11 @@ def _select_provider() -> str | None:
             value="codex",
             search_text="codex",
         ),
+        SelectItem(
+            title=[("", "Google Antigravity "), ("ansibrightblack", "[OAuth]\n")],
+            value="antigravity",
+            search_text="antigravity",
+        ),
     ]
     # Add API key options
     for key_info in SUPPORTED_API_KEYS:
@@ -71,7 +76,7 @@ def _build_provider_help() -> str:
     from klaude_code.config.builtin_config import SUPPORTED_API_KEYS
     # Use first word of name for brevity (e.g., "google" instead of "google gemini")
-    names = ["codex", "claude"] + [k.name.split()[0].lower() for k in SUPPORTED_API_KEYS]
+    names = ["codex", "claude", "antigravity"] + [k.name.split()[0].lower() for k in SUPPORTED_API_KEYS]
     return f"Provider name ({', '.join(names)})"
@@ -149,6 +154,39 @@ def login_command(
             except Exception as e:
                 log((f"Login failed: {e}", "red"))
                 raise typer.Exit(1) from None
+        case "antigravity":
+            from klaude_code.auth.antigravity.oauth import AntigravityOAuth
+            from klaude_code.auth.antigravity.token_manager import AntigravityTokenManager
+            token_manager = AntigravityTokenManager()
+            if token_manager.is_logged_in():
+                state = token_manager.get_state()
+                if state and not state.is_expired():
+                    log(("You are already logged in to Antigravity.", "green"))
+                    if state.email:
+                        log(f"  Email: {state.email}")
+                    log(f"  Project ID: {state.project_id}")
+                    expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.UTC)
+                    log(f"  Expires: {expires_dt.strftime('%Y-%m-%d %H:%M:%S UTC')}")
+                    if not typer.confirm("Do you want to re-login?"):
+                        return
+            log("Starting Antigravity OAuth login flow...")
+            log("A browser window will open for authentication.")
+            try:
+                oauth = AntigravityOAuth(token_manager)
+                state = oauth.login()
+                log(("Login successful!", "green"))
+                if state.email:
+                    log(f"  Email: {state.email}")
+                log(f"  Project ID: {state.project_id}")
+                expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.UTC)
+                log(f"  Expires: {expires_dt.strftime('%Y-%m-%d %H:%M:%S UTC')}")
+            except Exception as e:
+                log((f"Login failed: {e}", "red"))
+                raise typer.Exit(1) from None
         case _:
             from klaude_code.config.builtin_config import SUPPORTED_API_KEYS
@@ -174,7 +212,7 @@ def login_command(
 def logout_command(
-    provider: str = typer.Argument("codex", help="Provider to logout (codex|claude)"),
+    provider: str = typer.Argument("codex", help="Provider to logout (codex|claude|antigravity)"),
 ) -> None:
     """Logout from a provider."""
     match provider.lower():
@@ -202,8 +240,20 @@ def logout_command(
             if typer.confirm("Are you sure you want to logout from Claude?"):
                 token_manager.delete()
                 log(("Logged out from Claude.", "green"))
+        case "antigravity":
+            from klaude_code.auth.antigravity.token_manager import AntigravityTokenManager
+            token_manager = AntigravityTokenManager()
+            if not token_manager.is_logged_in():
+                log("You are not logged in to Antigravity.")
+                return
+            if typer.confirm("Are you sure you want to logout from Antigravity?"):
+                token_manager.delete()
+                log(("Logged out from Antigravity.", "green"))
         case _:
-            log((f"Error: Unknown provider '{provider}'. Supported: codex, claude", "red"))
+            log((f"Error: Unknown provider '{provider}'. Supported: codex, claude, antigravity", "red"))
             raise typer.Exit(1)
@@ -212,7 +262,7 @@ def register_auth_commands(app: typer.Typer) -> None:
     auth_app = typer.Typer(help="Login/logout", invoke_without_command=True)
     @auth_app.callback()
-    def auth_callback(ctx: typer.Context) -> None:
+    def auth_callback(ctx: typer.Context) -> None:  # pyright: ignore[reportUnusedFunction]
         """Authentication commands for managing provider logins."""
         if ctx.invoked_subcommand is None:
             typer.echo(ctx.get_help())

klaude-code 2.6.0__py3-none-any.whl → 2.8.0__py3-none-any.whl

klaude-code 2.6.0py3-none-any.whl → 2.8.0py3-none-any.whl