pcode 0.1.0__py3-none-any.whl

pcode/auth.py

@@ -0,0 +1,113 @@
+"""Shared authentication helpers for Anthropic access.
+
+API-key access uses ordinary Pydantic AI construction. Subscription access
+(pcode's own browser sign-in) speaks to the Claude Code endpoint, which
+requires the wire markers defined here.
+"""
+
+import os
+import re
+import shutil
+import subprocess
+from functools import cache
+
+# Compatibility markers used by Claude subscription OAuth traffic, not API keys.
+OAUTH_BETAS = {"claude-code-20250219", "oauth-2025-04-20"}
+OAUTH_PREAMBLE = "You are Claude Code, Anthropic's official CLI for Claude."
+# The endpoint gates newer models on the advertised version: below a model's
+# floor the request fails with `claude_code_version_too_old`, not a
+# model-not-found. Each new model raises its floor, so prefer the locally
+# installed Claude Code and keep this as the fallback for hosts without one.
+OAUTH_VERSION = "2.1.280"
+VERSION_TIMEOUT_SECONDS = 5.0
+VERSION_PATTERN = re.compile(r"\d+(?:\.\d+)+")
+
+
+def _parse_version(text: str) -> tuple[int, ...] | None:
+    match = VERSION_PATTERN.search(text)
+    return tuple(int(part) for part in match.group().split(".")) if match else None
+
+
+def oauth_version() -> str:
+    """Fallback Claude Code version, overridable without a release."""
+    value = os.environ.get("PCODE_CLAUDE_VERSION", "").strip()
+    if not value:
+        return OAUTH_VERSION
+    if not VERSION_PATTERN.fullmatch(value):
+        raise LoginError("PCODE_CLAUDE_VERSION must be a dotted version such as 2.1.280.")
+    return value
+
+
+@cache
+def oauth_user_agent() -> str:
+    """Claude Code identity to advertise, never older than `oauth_version()`.
+
+    Spoofing a version that was never released risks rejection, so the local
+    install is the only source of anything newer than the fallback.
+    """
+    version = oauth_version()
+    executable = shutil.which("claude")
+    if executable:
+        try:
+            result = subprocess.run(
+                [executable, "--version"],
+                capture_output=True,
+                text=True,
+                timeout=VERSION_TIMEOUT_SECONDS,
+                check=True,
+            )
+        except (OSError, subprocess.SubprocessError):
+            pass
+        else:
+            local = _parse_version(result.stdout)
+            if local and local > (_parse_version(version) or ()):
+                version = ".".join(str(part) for part in local)
+    return f"claude-cli/{version}"
+
+
+class LoginError(ValueError):
+    """Safe-to-display authentication setup failure."""
+
+
+class SubscriptionOAuthWire:
+    """Add Claude Code wire identity to an `AnthropicModel` subclass.
+
+    Pydantic's message mapping is a private integration seam, covered by wire
+    tests. This is compatibility support, not a claim of official third-party
+    OAuth support. Subclasses set `_subscription_oauth` when the resolved
+    credential is an OAuth token rather than an API key.
+    """
+
+    _subscription_oauth = False
+
+    async def _map_message(self, messages, model_request_parameters, model_settings):
+        system, mapped = await super()._map_message(
+            messages, model_request_parameters, model_settings
+        )
+        if self._subscription_oauth:
+            blocks = (
+                ([{"type": "text", "text": system}] if system else [])
+                if isinstance(system, str)
+                else list(system)
+            )
+            system = [{"type": "text", "text": OAUTH_PREAMBLE}, *blocks]
+        return system, mapped
+
+    def _get_betas_and_extra_headers(self, *args, **kwargs):
+        betas, headers = super()._get_betas_and_extra_headers(*args, **kwargs)
+        if self._subscription_oauth:
+            betas.update(OAUTH_BETAS)
+            headers.update({"User-Agent": oauth_user_agent(), "x-app": "cli"})
+        return betas, headers
+
+
+def anthropic_model(model: str, key: str, *, http_client=None):
+    from anthropic import AsyncAnthropic
+    from pydantic_ai.models.anthropic import AnthropicModel
+    from pydantic_ai.providers.anthropic import AnthropicProvider
+
+    # Runtime owns visible transport retries; HTTP errors must surface immediately.
+    client = AsyncAnthropic(api_key=key, http_client=http_client, max_retries=0)
+    return AnthropicModel(
+        model.removeprefix("anthropic:"), provider=AnthropicProvider(anthropic_client=client)
+    )

pcode/block.py

@@ -0,0 +1,39 @@
+"""One block style for a run of output, shared by scrollback and the live panel.
+
+A command, an edit or a live preview is drawn the same way everywhere: a top
+line that carries the heading, a two-space indented body, and a closing line.
+Scrollback draws it with Rich and the live panel with prompt_toolkit windows,
+so the containers cannot be one object; the heading text, the indent and the
+rule character live here so the two surfaces cannot drift apart.
+"""
+
+from rich.rule import Rule
+from rich.text import Text
+
+RULE = "─"
+INDENT = "  "
+# Heading markers. A non-zero exit is routine, so the marker alone reports it:
+# a word or an alarm colour would make every expected failure look like a crash.
+RUNNING = "⟳"
+DONE = "✓"
+FAILED = "✗"
+
+
+def block_heading(icon: str, title: str, elapsed_seconds: float | None = None) -> str:
+    """The text that sits on the opening line: marker, what ran, how long."""
+    elapsed = f" · {elapsed_seconds:.1f}s" if elapsed_seconds is not None else ""
+    return f"{icon} {title}{elapsed}"
+
+
+def block_rule(heading: str | None = None) -> Rule:
+    """The opening line when given a heading, the closing line when not."""
+    if heading is None:
+        return Rule(characters=RULE, style="pcode.muted")
+    # Left-aligned so the heading reads as a label on the line rather than as a
+    # centered banner; Rich fills the remainder of the row with the rule.
+    return Rule(
+        Text(heading, style="pcode.accent"),
+        characters=RULE,
+        style="pcode.muted",
+        align="left",
+    )

pcode/browser.py

@@ -0,0 +1,393 @@
+"""The conversation's browser: one real Chrome the bundled `browser` extension drives.
+
+Lives outside the extension because `/reload` re-imports extension modules,
+and the browser (with whatever the user logged in to) has to outlive that.
+Never persisted: a fresh pcode starts with the browser off, and the cookies of
+a session that was logged in leave with the process.
+
+Two decisions differ from Harness's own `PlaywrightBrowser` capability:
+
+- The session is owned here, not by the capability. That capability opens a
+  browser per agent run and closes it when the run ends; pcode runs one agent
+  run per turn, so under it the user would log in and lose the session at the
+  end of the turn. One `PlaywrightBrowserSession` is handed to every run,
+  parent or sub-agent, until `/browser off` or exit.
+- The browser is the user's installed Chrome, attached over CDP, not
+  Playwright's Chromium. Playwright launches its build with `--enable-automation`
+  (`navigator.webdriver` is true) and no Google API keys, and Google refuses to
+  sign in to that browser ("controlled through software automation"). Chrome
+  started by us with only a debugging port and its own profile carries neither
+  mark. When no Chrome is installed the session falls back to Playwright's
+  Chromium, which works everywhere except such sign-in pages.
+- The page opens in the browser's own default context rather than a fresh one
+  (`SharedContextSession`). Harness isolates every run in a new context so a
+  run never inherits a login; here inheriting is the point. On the Chrome we
+  launch, the default context is the pcode profile on disk, so a login made
+  once holds across pcode sessions. `/browser attach` (or
+  `PCODE_BROWSER_CDP_URL`) joins the user's everyday Chrome instead, where the
+  default context holds every account they are signed in to; that is the
+  higher-risk choice and is never the default.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+import socket
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+# A coding agent's usual target is its own dev server on localhost, which the
+# Harness default (an SSRF guard for untrusted deployments) would refuse.
+BLOCK_PRIVATE_ADDRESSES = False
+# Every action returns page text; below the Harness default because a browsing
+# turn is many actions and each lands in the conversation.
+MAX_CONTENT_TOKENS = 2500
+CHROME_START_SECONDS = 20
+CHROME_CANDIDATES = (
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "google-chrome",
+    "google-chrome-stable",
+    "chromium",
+    "chromium-browser",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+)
+
+
+def chrome_executable() -> str | None:
+    """The Chrome to launch: `PCODE_BROWSER_CHROME`, else the first installed candidate."""
+    configured = os.environ.get("PCODE_BROWSER_CHROME", "").strip()
+    candidates = (configured,) if configured else CHROME_CANDIDATES
+    for candidate in candidates:
+        if "/" in candidate:
+            if Path(candidate).is_file():
+                return candidate
+        elif shutil.which(candidate):
+            return candidate
+    return None
+
+
+def profile_dir() -> Path:
+    """Chrome's profile for the agent, apart from the user's own so no login leaks in."""
+    state = Path(os.environ.get("XDG_STATE_HOME") or Path.home() / ".local" / "state")
+    return state / "pcode" / "chrome"
+
+
+def _chrome_profile_dirs() -> list[Path]:
+    """Where Chrome, Chromium, and Edge keep their debugging port files."""
+    home = Path.home()
+    return [
+        home / "Library" / "Application Support" / "Google" / "Chrome",
+        home / "Library" / "Application Support" / "Chromium",
+        home / ".config" / "google-chrome",
+        home / ".config" / "chromium",
+        home / "Library" / "Application Support" / "Microsoft Edge",
+        home / ".config" / "microsoft-edge",
+    ]
+
+
+def running_chrome_url() -> str | None:
+    """The CDP endpoint of a user's Chromium-based browser with remote debugging on.
+
+    `PCODE_BROWSER_CDP_URL` wins. Otherwise Chrome writes `DevToolsActivePort`
+    (port, then the browser websocket path) into its profile when started with
+    `--remote-debugging-port` or when `chrome://inspect/#remote-debugging` is
+    toggled on; `PCODE_BROWSER_PORT_FILE` names that file elsewhere.
+    """
+    configured = os.environ.get("PCODE_BROWSER_CDP_URL", "").strip()
+    if configured:
+        return configured
+    named = os.environ.get("PCODE_BROWSER_PORT_FILE", "").strip()
+    files = [Path(named)] if named else [d / "DevToolsActivePort" for d in _chrome_profile_dirs()]
+    for file in files:
+        try:
+            port, path = file.read_text().split()[:2]
+        except (OSError, ValueError):
+            continue
+        return f"ws://127.0.0.1:{int(port)}{path}"
+    return None
+
+
+REMOTE_DEBUGGING_PAGE = "chrome://inspect/#remote-debugging"
+
+
+def show_remote_debugging_toggle() -> bool:
+    """Open Chrome's remote-debugging switch in the user's own Chrome; False if none is installed.
+
+    Chrome forwards a URL given to a second invocation to the running instance,
+    or starts one on the default profile, so this lands in the everyday browser
+    either way. On macOS that goes through `open -a`: a cold start from the
+    binary itself drops a `chrome://` URL on the floor. Detached: the process
+    is not ours to wait on.
+    """
+    executable = chrome_executable()
+    if executable is None:
+        return False
+    command = [executable, REMOTE_DEBUGGING_PAGE]
+    if sys.platform == "darwin" and ".app/Contents/MacOS/" in executable:
+        bundle = Path(executable)
+        while bundle.suffix != ".app":
+            bundle = bundle.parent
+        command = ["open", "-a", str(bundle), REMOTE_DEBUGGING_PAGE]
+    _detach(command)
+    return True
+
+
+def _detach(command: list[str]) -> None:
+    subprocess.Popen(
+        command,
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,
+    )
+
+
+def _free_port() -> int:
+    with socket.socket() as probe:
+        probe.bind(("127.0.0.1", 0))
+        return probe.getsockname()[1]
+
+
+def _session_class():
+    from pydantic_ai_harness.playwright import PlaywrightBrowserSession
+
+    class SharedContextSession(PlaywrightBrowserSession):
+        """A session whose page lives in the browser's default context.
+
+        Overrides the private `_launch` of the pinned Harness revision: the
+        only difference is `browser.contexts[0]` in place of `new_context()`
+        when the browser has one, so the page shares that context's cookies.
+        The guards Harness installs (route, websocket, page wiring) are kept.
+        A browser reached over CDP is left running by Harness's own teardown,
+        which only disconnects; the page opened here is closed first so no
+        stray tab is left in the user's window.
+        """
+
+        async def _launch(self) -> None:
+            assert self._driver_cm is not None
+            if self._driver is None:
+                self._driver = await self._driver_cm.__aenter__()
+                self._driver_entered = True
+            if self._browser is not None:
+                stale = self._browser
+                await self._bounded(stale.close())
+                self._browser = None
+            browser = await self._connect(self._driver)
+            if browser is None:
+                return
+            self._browser = browser
+            if browser.contexts:
+                context = browser.contexts[0]
+            else:  # pragma: no cover - a launched Chromium has none until asked
+                context = await self._bounded(
+                    browser.new_context(service_workers="block", accept_downloads=False)
+                )
+            self._context = context
+            page = await self._bounded(context.new_page())
+            if self.policy.enforced():
+                await self._bounded(context.route("**/*", self._route_guard))
+                await self._bounded(context.route_web_socket("**/*", self._websocket_guard))
+            self._wire_page(page)
+            self.pages.append(page)
+            self.page = page
+
+        async def list_tabs(self) -> list[tuple[str, str]]:
+            """Read browser targets over CDP, without evaluating possibly hung pages.
+
+            A browser's debugging switch can expose only a WebSocket, with no
+            HTTP `/json/list` endpoint. Reuse Playwright's connection instead.
+            """
+            await self.ensure_page()
+            assert self._browser is not None
+            cdp = await self._bounded(self._browser.new_browser_cdp_session())
+            try:
+                result = await self._bounded(cdp.send("Target.getTargets"))
+            finally:
+                await self._bounded(cdp.detach())
+            return [
+                (target.get("title", ""), target.get("url", ""))
+                for target in result["targetInfos"]
+                if target.get("type") == "page"
+            ]
+
+        async def __aexit__(self, exc_type, *rest) -> None:
+            for page in list(self.pages):
+                try:
+                    await page.close()
+                except Exception:  # noqa: BLE001 - the tab may already be gone.
+                    pass
+            await super().__aexit__(exc_type, *rest)
+
+    return SharedContextSession
+
+
+class BrowserState:
+    """Whether the browser tools are offered, and the live session behind them."""
+
+    def __init__(self) -> None:
+        self.enabled = False
+        self.attach = False
+        self.session: Any = None
+        self.toolset: Any = None
+        self.cdp_url: str | None = None
+        self.process: subprocess.Popen | None = None
+        self._armed = False
+        self._launch_lock: asyncio.Lock | None = None
+
+    @property
+    def attached(self) -> bool:
+        """Joined a Chrome someone else started, which is theirs to close."""
+        return self.attach
+
+    def open(self):
+        """Build (not launch) the session and toolset; idempotent.
+
+        Raises `ValueError` in attach mode when no running Chrome is found.
+        """
+        if self.session is None:
+            from pydantic_ai_harness.playwright import EgressPolicy, PlaywrightBrowserToolset
+
+            if self.attach:
+                self.cdp_url = running_chrome_url()
+                if self.cdp_url is None:
+                    raise ValueError(
+                        "No running Chrome, Chromium, or Edge with remote debugging found. "
+                        "Enable remote debugging in your browser "
+                        "(chrome://inspect/#remote-debugging in Chrome), "
+                        "or set PCODE_BROWSER_CDP_URL."
+                    )
+            elif chrome_executable():
+                # The port is chosen now so the session can be built before the
+                # browser exists; Chrome starts on the first tool call.
+                self.cdp_url = f"http://127.0.0.1:{_free_port()}"
+            else:
+                self.cdp_url = None
+            self.session = _session_class()(
+                policy=EgressPolicy(block_private_addresses=BLOCK_PRIVATE_ADDRESSES),
+                headless=False,
+                cdp_url=self.cdp_url,
+                auto_install_chromium=True,
+            )
+            self.toolset = PlaywrightBrowserToolset(
+                session=self.session, max_content_tokens=MAX_CONTENT_TOKENS
+            )
+        return self.toolset
+
+    async def arm(self) -> None:
+        """Enter the session once, on the loop the tools run on.
+
+        Entering is cheap and launches nothing. Entering twice would discard the
+        driver handle, so it is guarded.
+        """
+        if self.session is not None and not self._armed:
+            await self.session.__aenter__()
+            self._armed = True
+
+    async def ensure_chrome(self) -> str:
+        """Start Chrome on the debugging port unless one is already answering there.
+
+        Returns a line describing what happened, for a notice. Nothing to do
+        when attaching to a foreign endpoint or falling back to Chromium.
+        """
+        if self.cdp_url is None or self.attached:
+            return ""
+        if self._launch_lock is None:
+            self._launch_lock = asyncio.Lock()
+        async with self._launch_lock:
+            if self.process is not None and self.process.poll() is None:
+                return ""
+            if await self._answering():
+                return ""
+            executable = chrome_executable()
+            if executable is None:  # pragma: no cover - open() would have chosen Chromium
+                return ""
+            port = self.cdp_url.rsplit(":", 1)[1]
+            profile = profile_dir()
+            profile.mkdir(parents=True, exist_ok=True)
+            self.process = subprocess.Popen(
+                [
+                    executable,
+                    f"--remote-debugging-port={port}",
+                    f"--user-data-dir={profile}",
+                    "--no-first-run",
+                    "--no-default-browser-check",
+                    "about:blank",
+                ],
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+            deadline = asyncio.get_running_loop().time() + CHROME_START_SECONDS
+            while asyncio.get_running_loop().time() < deadline:
+                if self.process.poll() is not None:
+                    raise RuntimeError(
+                        f"Chrome exited at startup (code {self.process.returncode})."
+                    )
+                if await self._answering():
+                    return f"Started Chrome ({executable}) with profile {profile}."
+                await asyncio.sleep(0.2)
+            raise RuntimeError(
+                f"Chrome did not open its debugging port within {CHROME_START_SECONDS}s."
+            )
+
+    async def _answering(self) -> bool:
+        assert self.cdp_url is not None
+        import httpx
+
+        try:
+            async with httpx.AsyncClient(timeout=1.0) as client:
+                response = await client.get(self.cdp_url.rstrip("/") + "/json/version")
+            return response.status_code == 200
+        except httpx.HTTPError:
+            return False
+
+    async def close(self) -> None:
+        """Disconnect, then quit the Chrome we started; safe when nothing was."""
+        session, self.session, self.toolset = self.session, None, None
+        armed, self._armed = self._armed, False
+        process, self.process = self.process, None
+        self.cdp_url = None
+        self.attach = False
+        try:
+            if session is not None and armed:
+                await session.__aexit__(None, None, None)
+        finally:
+            if process is not None and process.poll() is None:
+                process.terminate()
+                try:
+                    await asyncio.to_thread(process.wait, 5)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+
+    async def list_tabs(self) -> list[tuple[str, str]]:
+        """Every tab as (title, url), the user's included, without evaluating pages."""
+        if self.session is None:
+            return []
+        return await self.session.list_tabs()
+
+    @property
+    def launched(self) -> bool:
+        return self.session is not None and self.session.page is not None
+
+    def describe(self) -> str:
+        """One line for `/browser status`."""
+        if not self.enabled:
+            return "off"
+        if self.cdp_url is None:
+            how = "Playwright's Chromium (no Chrome found; Google sign-in will refuse it)"
+        elif self.attached:
+            how = f"attached to your browser at {self.cdp_url}"
+        else:
+            how = f"own Chrome on {self.cdp_url}, profile {profile_dir()}" + (
+                "" if self.process is not None and self.process.poll() is None else " (not started)"
+            )
+        page = self.session.page if self.launched else None
+        return f"on, {how}" + (f", at {page.url}" if page is not None else "")
+
+
+STATE = BrowserState()