bazaar-contrib-claude-code 0.3.0rc1__py3-none-any.whl

bazaar_contrib_claude_code/__init__.py

@@ -0,0 +1,78 @@
+"""Register the ClaudeCode builder and its privately composed Harness."""
+
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any, ClassVar
+
+from bazaar_contrib_audit import AUDIT
+from bazaar_contrib_harness import (
+    HARNESS,
+    HARNESS_BUILDERS,
+    HARNESS_INPUT,
+    HarnessBuilderConfig,
+    HarnessInspection,
+    harness_builder_key,
+)
+from bazaar_contrib_timer import TIMER
+from bazaar_core import Context, Contrib
+from pydantic import BaseModel, ConfigDict
+
+from .inspection import inspect
+from .runtime import ClaudeCodeHarness
+
+
+class Config(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    model: str | None = None
+    effort: str | None = None
+
+
+@asynccontextmanager
+async def lifespan(ctx: Context, config: Config):
+    instance = ClaudeCodeHarness(
+        ctx.accept(HARNESS_INPUT),
+        ctx.accept(TIMER),
+        ctx.accept(AUDIT),
+        config.model,
+        config.effort,
+    )
+    ctx.offer(HARNESS, instance)
+    try:
+        yield
+    finally:
+        await instance.aclose()
+
+
+harness = Contrib(
+    config=Config,
+    accepts=[HARNESS_INPUT, TIMER, AUDIT],
+    offers=[HARNESS],
+    lifespan=lifespan,
+)
+
+
+class BuilderConfig(HarnessBuilderConfig):
+    kind: ClassVar[str] = "claudecode"
+    entity_model: ClassVar[type[BaseModel]] = Config
+    entry: ClassVar[Contrib[Any]] = harness
+
+    @classmethod
+    async def inspect(cls, workspace: Path, *, timeout: float) -> HarnessInspection:  # noqa: ASYNC109
+        return await inspect(workspace, timeout=timeout)
+
+
+@asynccontextmanager
+async def builder_lifespan(ctx: Context, config: BuilderConfig):
+    with ctx.accept(HARNESS_BUILDERS).register(config.builder()) as builder:
+        ctx.offer(harness_builder_key(builder.kind), builder)
+        yield
+
+
+builder = Contrib(
+    config=BuilderConfig,
+    accepts=[HARNESS_BUILDERS],
+    offers=[harness_builder_key("claudecode")],
+    lifespan=builder_lifespan,
+)

bazaar_contrib_claude_code/approval.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from dataclasses import dataclass
+from time import time_ns
+
+from bazaar_contrib_harness import ApprovalRequest, ApprovalResult
+from pydantic import JsonValue
+
+from .protocol import ClaudeProtocolError, JsonObject
+
+
+@dataclass(frozen=True, slots=True)
+class ApprovalEnvelope:
+    """Claude permission request plus its provider-neutral projection."""
+
+    control_request_id: str
+    tool_name: str
+    tool_input: Mapping[str, object]
+    request: ApprovalRequest
+
+
+def parse_approval_request(
+    message: Mapping[str, object],
+    *,
+    session_id: str,
+    turn_id: str,
+) -> ApprovalEnvelope:
+    if message.get("type") != "control_request":
+        raise ClaudeProtocolError("message is not a control request")
+    control_request_id = message.get("request_id")
+    if not isinstance(control_request_id, str) or not control_request_id:
+        raise ClaudeProtocolError("permission control request requires a request_id")
+    request = message.get("request")
+    if not isinstance(request, Mapping) or request.get("subtype") != "can_use_tool":
+        raise ClaudeProtocolError("unsupported Claude control request subtype")
+    tool_use_id = request.get("tool_use_id")
+    if not isinstance(tool_use_id, str) or not tool_use_id:
+        raise ClaudeProtocolError("permission request requires a tool_use_id")
+    tool_name = request.get("tool_name")
+    if not isinstance(tool_name, str) or not tool_name:
+        raise ClaudeProtocolError("permission request requires a tool_name")
+    tool_input = request.get("input")
+    if not isinstance(tool_input, Mapping):
+        raise ClaudeProtocolError("permission request input must be an object")
+
+    details = _details(request, tool_input)
+    return ApprovalEnvelope(
+        control_request_id=control_request_id,
+        tool_name=tool_name,
+        tool_input=tool_input,
+        request=ApprovalRequest(
+            request_id=tool_use_id,
+            session_id=session_id,
+            action=tool_name,
+            created_at_ms=time_ns() // 1_000_000,
+            turn_id=turn_id,
+            details=details,
+        ),
+    )
+
+
+def build_approval_response(
+    approval: ApprovalEnvelope, result: ApprovalResult
+) -> JsonObject:
+    if result.request_id != approval.request.request_id:
+        raise ValueError("approval result request id does not match tool use")
+    if result.decision == "approved":
+        return {"behavior": "allow", "updatedInput": dict(approval.tool_input)}
+    return {
+        "behavior": "deny",
+        "message": result.reason or "Permission denied by the user.",
+    }
+
+
+_MAX_APPROVAL_DETAIL = 4_000
+
+
+def _details(
+    request: Mapping[str, object], tool_input: Mapping[str, object]
+) -> dict[str, JsonValue]:
+    reasons: list[str] = []
+    for field_name in ("description", "title", "display_name", "decision_reason"):
+        value = request.get(field_name)
+        if isinstance(value, str) and value.strip() and value.strip() not in reasons:
+            reasons.append(value.strip())
+    try:
+        encoded_input = json.dumps(
+            dict(tool_input),
+            ensure_ascii=False,
+            sort_keys=True,
+            separators=(",", ":"),
+        )
+    except TypeError, ValueError:
+        encoded_input = ""
+    details: dict[str, JsonValue] = {}
+    if reasons:
+        details["reason"] = "\n".join(reasons)
+    tool_name = request["tool_name"]
+    if isinstance(tool_name, str) and tool_name:
+        details["tool_name"] = tool_name
+    if encoded_input:
+        details["tool_input"] = (
+            encoded_input[: _MAX_APPROVAL_DETAIL - 1] + "…"
+            if len(encoded_input) > _MAX_APPROVAL_DETAIL
+            else encoded_input
+        )
+    return details
+
+
+__all__ = [
+    "ApprovalEnvelope",
+    "build_approval_response",
+    "parse_approval_request",
+]

bazaar_contrib_claude_code/children.py

@@ -0,0 +1,169 @@
+"""The runtime processes this provider started and that have not ended: when
+going down runs out of time, the node ends them itself before it exits, so
+none is left running without it. Each has its own group or Windows Job, so
+what it starts in turn ends with it."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import signal
+import subprocess
+import sys
+from collections.abc import Sequence
+from typing import Any
+
+import psutil
+from bazaar_contrib_timer import Timer
+
+if sys.platform == "win32":
+    from .windows_job import CREATE_SUSPENDED, WindowsJob
+
+# how long a runtime asked to end gets before it is killed
+END_GRACE_SECONDS = 2.0
+
+
+def own_group() -> dict[str, Any]:
+    """What `create_subprocess_exec` takes to start a process in a group of
+    its own: the terminal's Ctrl-C does not reach it, the node ends it.
+    On Windows, Children.started assigns the suspended process before resuming."""
+
+    if sys.platform == "win32":
+        return {"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP | CREATE_SUSPENDED}
+    return {"start_new_session": True}
+
+
+class Children:
+    def __init__(self, timer: Timer | None = None):
+        self.timer = timer
+        self._running: set[int] = set()
+        self._reapers: set[asyncio.Task[None]] = set()
+        if sys.platform == "win32":
+            self._jobs: dict[int, WindowsJob] = {}
+
+    def started(self, pid: int) -> None:
+        self._running.add(pid)
+        if sys.platform == "win32":
+            # Own the entire family before the CLI can create any descendants.
+            job = WindowsJob()
+            self._jobs[pid] = job
+            job.assign(pid)
+            psutil.Process(pid).resume()
+
+    def reaping(self, task: asyncio.Task[None]) -> None:
+        self._reapers.add(task)
+        task.add_done_callback(self._reapers.discard)
+
+    def snapshot(self, pid: int) -> tuple[psutil.Process, ...]:
+        # Cancellation must not kill the root before its descendants are captured.
+        try:
+            process = psutil.Process(pid)
+            descendants = process.children(recursive=True)
+        except psutil.NoSuchProcess:
+            return ()
+        return (process, *descendants)
+
+    async def ended(self, pid: int, tree: Sequence[psutil.Process] = ()) -> None:
+        """A runtime is gone: what it started and left running goes with it, so
+        nothing it began outlives it unregistered."""
+
+        if sys.platform == "win32":
+            if job := self._jobs.get(pid):
+                job.close()
+                del self._jobs[pid]
+        else:
+            await asyncio.to_thread(_signal_group, pid, signal.SIGKILL)
+        await asyncio.to_thread(_kill_tree, tree)
+        self._running.discard(pid)
+
+    async def wait(self, tree: Sequence[psutil.Process]) -> None:
+        remaining = list(tree)
+        while remaining:
+            _, remaining = await asyncio.to_thread(
+                psutil.wait_procs, remaining, timeout=0
+            )
+            if remaining:
+                if self.timer is None:
+                    await asyncio.sleep(0.05)
+                else:
+                    await self.timer.create(50).wait()
+
+    async def end_all(self) -> None:
+        """End every runtime still running, with what it started: asked first,
+        killed when it is still there after the grace."""
+
+        pids = tuple(self._running)
+        if not pids:
+            await asyncio.gather(*tuple(self._reapers), return_exceptions=True)
+            return
+        trees: dict[int, tuple[psutil.Process, ...]] = {}
+
+        def snapshot() -> None:
+            for pid in pids:
+                trees[pid] = self.snapshot(pid)
+
+        try:
+            capture = asyncio.create_task(asyncio.to_thread(snapshot))
+            try:
+                await asyncio.shield(capture)
+            except asyncio.CancelledError:
+                await capture
+                raise
+            if sys.platform == "win32":
+                return
+            for pid in pids:
+                await asyncio.to_thread(_signal_group, pid, signal.SIGTERM)
+            loop = asyncio.get_running_loop()
+            deadline = loop.time() + END_GRACE_SECONDS
+            roots = [tree[0] for tree in trees.values() if tree]
+            remaining = [process for tree in trees.values() for process in tree[1:]]
+            while loop.time() < deadline:
+                _, remaining = await asyncio.to_thread(
+                    psutil.wait_procs, remaining, timeout=0
+                )
+                if not remaining and not await asyncio.to_thread(
+                    lambda: any(root.is_running() for root in roots)
+                ):
+                    break
+                if self.timer is None:
+                    await asyncio.sleep(0.05)
+                else:
+                    await self.timer.create(50).wait()
+        finally:
+            for pid in pids:
+                await self.ended(pid, trees.get(pid, ()))
+            await asyncio.gather(*tuple(self._reapers), return_exceptions=True)
+
+
+def _kill_tree(tree: Sequence[psutil.Process]) -> None:
+    for process in reversed(tree):
+        try:
+            process.kill()
+        except psutil.NoSuchProcess:
+            pass
+
+
+if sys.platform != "win32":
+
+    def _signal_group(pid: int, number: signal.Signals) -> None:
+        try:
+            os.killpg(pid, number)
+        except ProcessLookupError:
+            pass
+        except PermissionError:
+            if sys.platform != "darwin" or _group_has_live_members(pid):
+                raise
+
+    def _group_has_live_members(pid: int) -> bool:
+        # Darwin also returns EPERM for a group containing only zombies. Check
+        # the kernel's process list before treating a permission error as exit.
+        for process in psutil.process_iter(("pid", "status")):
+            try:
+                if (
+                    process.info["status"] != psutil.STATUS_ZOMBIE
+                    and os.getpgid(process.pid) == pid
+                ):
+                    return True
+            except ProcessLookupError:
+                pass
+        return False