pcode 0.1.0__py3-none-any.whl

pcode/llm_proxy.py

@@ -0,0 +1,44 @@
+"""Codex-only proxy transport; never change process-wide HTTP settings."""
+
+import httpx2
+from pydantic_ai.models import get_user_agent
+from pydantic_ai.providers.openai_codex import OpenAICodexCredentialSource, OpenAICodexProvider
+
+
+class ProxiedCodexProvider(OpenAICodexProvider):
+    """Own a dedicated proxied client, including across repeated agent runs."""
+
+    def __init__(
+        self, proxy: str, *, credential_source: OpenAICodexCredentialSource | None = None
+    ) -> None:
+        # Validate without echoing a URL that may contain proxy credentials.
+        try:
+            url = httpx2.URL(proxy)
+            if url.scheme not in {"http", "https"} or not url.host:
+                raise ValueError
+        except (ValueError, httpx2.InvalidURL):
+            raise ValueError(
+                "PCODE_LLM_PROXY must be a valid http:// or https:// proxy URL"
+            ) from None
+        self._proxy_url = proxy
+        client = self._new_http_client()
+        super().__init__(credential_source=credential_source, http_client=client)
+        # Pydantic AI 2.43's Provider context manager closes owned clients and
+        # recreates them on re-entry. Injected clients are otherwise caller-owned.
+        # These private ownership hooks are covered by lifecycle regression tests.
+        self._own_http_client = client
+        self._http_client_factory = self._create_http_client
+
+    def _new_http_client(self) -> httpx2.AsyncClient:
+        return httpx2.AsyncClient(
+            proxy=self._proxy_url,
+            trust_env=False,
+            timeout=httpx2.Timeout(600, connect=5),
+            headers={"User-Agent": get_user_agent()},
+        )
+
+    def _create_http_client(self) -> httpx2.AsyncClient:
+        client = self._new_http_client()
+        client.auth = self._auth
+        self._http_client = client
+        return client

pcode/logins.py

@@ -0,0 +1,233 @@
+"""Provider sign-in and sign-out for a session: `/login` and `/logout`.
+
+`Logins` is a collaborator of `SessionController`, which holds one as
+`controller.logins`. The commands only record what was asked for
+(`controller.login_requested` / `logout_requested`); the controller's command
+loop runs the browser flow once the handler returns.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import TYPE_CHECKING
+
+from pcode.preferences import load_preferences
+
+if TYPE_CHECKING:
+    from pcode.controller import SessionController
+
+
+class Logins:
+    """Signs a session in to, and out of, the providers pcode can store logins for."""
+
+    def __init__(self, controller: SessionController) -> None:
+        self.controller = controller
+
+    @property
+    def view(self):
+        return self.controller.view
+
+    def login(self, argument: str) -> None:
+        # Signing in stores a credential; it does not require the conversation to
+        # already be on Anthropic. A non-Anthropic session keeps its own model.
+        from pcode.models import login_sources
+
+        sources = login_sources()
+        source = argument.strip() or sources[0]
+        if source not in sources:
+            self.view.note(f"Usage: /login [{'|'.join(sources)}]")
+            return
+        self.controller.login_requested = source
+
+    def logout(self, argument: str) -> None:
+        source = argument.strip() or "anthropic"
+        if source == "openai-codex":
+            self.controller.logout_requested = source
+            return
+        if source != "anthropic":
+            self.view.note("Usage: /logout [anthropic|openai-codex]")
+            return
+        self.logout_anthropic()
+
+    def logout_anthropic(self) -> None:
+        from pcode.anthropic_oauth import credentials_path, delete_tokens
+        from pcode.auth import LoginError
+
+        try:
+            removed = delete_tokens(credentials_path())
+        except LoginError as error:
+            self.view.error(str(error))
+            return
+        if os.environ.get("PCODE_ANTHROPIC_AUTH", "").strip() == "oauth":
+            del os.environ["PCODE_ANTHROPIC_AUTH"]
+        # The stored sign-in is gone; a saved "oauth" choice would now resolve
+        # to a credential that no longer exists.
+        if load_preferences().get("anthropic_auth") == "oauth":
+            self.controller.forget_defaults("anthropic_auth")
+        if not removed:
+            self.view.note("No stored Anthropic login to remove.")
+            return
+        self.view.note(
+            "Removed pcode's stored Anthropic login. This conversation keeps its current "
+            "model until the token expires; use /login again or set ANTHROPIC_API_KEY."
+        )
+
+    async def perform_login(self, source: str | None) -> None:
+        if source == "openai-codex":
+            await self.login_codex()
+        elif source == "meridian":
+            await self.login_meridian()
+        elif source == "claude":
+            await self.login_claude()
+        else:
+            await self.login_anthropic()
+
+    async def login_meridian(self) -> None:
+        """Run Claude Code's own sign-in for the Meridian this session uses."""
+        from pcode.auth import LoginError
+        from pcode.meridian_setup import claude_login, login_target
+
+        try:
+            target = await asyncio.to_thread(login_target)
+            self.view.note(
+                f"Signing in to Claude for Meridian ({target.label}) with `claude auth login`. "
+                "Finish in the browser (Ctrl+C cancels)."
+            )
+            status = await claude_login(self.view.note, target)
+            plan = status.get("subscriptionType")
+            self.view.note(
+                f"Signed in to Claude ({target.label}"
+                + (f", {plan} plan" if plan else "")
+                + "). Meridian uses it from its next request; pcode stores nothing."
+            )
+        except asyncio.CancelledError:
+            self.view.note("Claude sign-in cancelled.")
+            raise
+        except LoginError as error:
+            self.view.error(str(error))
+        except Exception:
+            self.view.error("Claude sign-in failed. No credential details were logged.")
+
+    async def login_claude(self) -> None:
+        """Run Claude Code's own sign-in for `claude:` models, with the CLI they run."""
+        from pcode.auth import LoginError
+        from pcode.claude_sdk import LOGIN_ENV, MISSING_SDK, cli_path
+        from pcode.meridian_setup import LoginTarget, claude_login
+        from pcode.models import claude_sdk_installed
+
+        if not claude_sdk_installed():
+            self.view.error(MISSING_SDK)
+            return
+        target = LoginTarget(os.environ.get("CLAUDE_CONFIG_DIR") or None, "Claude Code's login")
+        try:
+            self.view.note(
+                "Signing in to Claude Code with `claude auth login`. "
+                "Finish in the browser (Ctrl+C cancels)."
+            )
+            # Scrubbed as the requests are, so an API key cannot pass for the login.
+            status = await claude_login(
+                self.view.note,
+                target,
+                executable=cli_path(),
+                retry="/login claude",
+                extra_env=LOGIN_ENV,
+                for_meridian=False,
+            )
+            plan = status.get("subscriptionType")
+            self.view.note(
+                "Signed in to Claude Code"
+                + (f" ({plan} plan)" if plan else "")
+                + ". claude: models use it from their next request; pcode stores nothing."
+            )
+        except asyncio.CancelledError:
+            self.view.note("Claude sign-in cancelled.")
+            raise
+        except LoginError as error:
+            self.view.error(str(error))
+        except Exception:
+            self.view.error("Claude sign-in failed. No credential details were logged.")
+
+    async def login_codex(self) -> None:
+        from pcode.agent import codex_model
+        from pcode.auth import LoginError
+        from pcode.codex_login import credentials_path, login
+
+        controller = self.controller
+        self.view.note(
+            "Sign in with your ChatGPT account in the browser. "
+            "If no browser opens, visit this URL (Ctrl+C cancels):"
+        )
+        try:
+            await login(notify=self.view.note)
+            # Codex credentials are read when the model is built, so a Codex
+            # conversation must rebuild its model to adopt the new sign-in.
+            codex = (controller.model or "").startswith("openai-codex:")
+            if codex and hasattr(controller.runtime, "agent"):
+                controller.runtime.agent.model = await asyncio.to_thread(
+                    codex_model, controller.model
+                )
+            self.view.note(
+                f"Signed in to OpenAI Codex. Credentials are stored in {credentials_path()} "
+                "(owner-only) and refreshed automatically; /logout openai-codex removes them."
+            )
+        except asyncio.CancelledError:
+            self.view.note("OpenAI Codex sign-in cancelled.")
+            raise
+        except LoginError as error:
+            self.view.error(str(error))
+        except Exception:
+            self.view.error("OpenAI Codex sign-in failed. No credential details were logged.")
+
+    async def perform_logout(self) -> None:
+        from pcode.auth import LoginError
+        from pcode.codex_login import credentials_path, delete_credentials
+
+        self.controller.logout_requested = None
+        try:
+            removed = await asyncio.to_thread(delete_credentials, credentials_path())
+        except LoginError as error:
+            self.view.error(str(error))
+            return
+        self.view.note(
+            "Removed pcode's stored OpenAI Codex login. "
+            "New models fall back to the CLI login, if present; that login was not removed. "
+            "The current model retains its in-memory token until it expires."
+            if removed
+            else "No stored pcode OpenAI Codex login to remove. CLI login is unchanged."
+        )
+
+    async def login_anthropic(self) -> None:
+        from pcode.anthropic_oauth import AnthropicOAuthModel, credentials_path, login
+        from pcode.auth import LoginError
+
+        controller = self.controller
+        self.view.note(
+            "Opening claude.ai to sign in with your Anthropic account. "
+            "If no browser opens, visit this URL (Ctrl+C cancels):"
+        )
+        try:
+            await login(notify=self.view.note)
+            # Only an Anthropic conversation adopts the new credential; a Codex
+            # or Meridian session keeps its own model and provider.
+            if controller.model and controller.model.startswith("anthropic:"):
+                controller.runtime.agent.model = await asyncio.to_thread(
+                    AnthropicOAuthModel, controller.model
+                )
+            os.environ["PCODE_ANTHROPIC_AUTH"] = "oauth"
+            controller.persist_defaults(anthropic_auth="oauth")
+            self.view.note(
+                f"Signed in to Anthropic. Credentials are stored in {credentials_path()} "
+                "(owner-only) and refreshed automatically; /logout removes them."
+            )
+            self.view.note(
+                "Future launches use this login automatically. "
+                "Set PCODE_ANTHROPIC_AUTH=api-key to use ANTHROPIC_API_KEY instead."
+            )
+        except asyncio.CancelledError:
+            self.view.note("Anthropic sign-in cancelled.")
+            raise
+        except LoginError as error:
+            self.view.error(str(error))
+        except Exception:
+            self.view.error("Anthropic sign-in failed. No credential details were logged.")