Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python
14.8 KB
Raw Blame
"""Controllable native harness used by application and browser tests."""

import asyncio
import uuid
from dataclasses import dataclass
from unittest.mock import AsyncMock

from free_claude_code.application.code_sessions.models import (
    CodeCatalog,
    CodeConflictError,
    CodeMode,
    CodeModel,
    CodeUnavailableError,
    CodeValidationError,
    HarnessEvent,
    ItemUpdate,
    NativeHistoryMissing,
    NativeThread,
    NativeTurn,
    PromptRequest,
    RunStatus,
)
from free_claude_code.application.code_sessions.ports import EventSink, HarnessSelection
from free_claude_code.config.model_refs import split_provider_model_ref
from free_claude_code.core.json_types import JsonObject
from free_claude_code.runtime.codex_app_server import CodexAppServer
from free_claude_code.runtime.codex_protocol import CodexProtocol


class CodexPackets:
    """Feed native packets through the real adapter without starting a process."""

    def __init__(self, connection):
        self.connection = connection
        self.native = CodexAppServer([], {}, "", connection.sink)
        self.native.generation = connection.generation
        self.native._protocol = CodexProtocol(connection.generation)
        self.parents: dict[str, str] = {}
        self.native.rpc = AsyncMock(side_effect=self.metadata)

    async def metadata(self, method: str, params: JsonObject) -> JsonObject:
        assert method == "thread/read" and params["includeTurns"] is False
        identity = params["threadId"]
        assert isinstance(identity, str)
        parent = self.parents.get(identity)
        return {
            "thread": {
                "id": identity,
                "source": {"subAgent": {"thread_spawn": {"parent_thread_id": parent}}}
                if parent
                else "vscode",
            }
        }

    async def send(self, method, params):
        if self.native.thread_id is None:
            future = asyncio.get_running_loop().create_future()
            self.native._pending["register"] = ("thread/resume", future)
            await self.native._packet(
                {
                    "id": "register",
                    "result": {"thread": {"id": self.connection.thread_id}},
                }
            )
        await self.native._packet({"method": method, "params": params})
        self.native._queue.put_nowait(None)
        await self.native._dispatch()

    async def spawn(self, child="child", parent=None):
        self.parents[child] = parent or self.connection.thread_id
        await self.send(
            "thread/started",
            {
                "thread": {
                    "id": child,
                    "source": {
                        "subAgent": {
                            "thread_spawn": {
                                "parent_thread_id": parent or self.connection.thread_id,
                                "depth": 1 if parent is None else 2,
                            }
                        }
                    },
                }
            },
        )

    async def review(
        self, child="child", review_id="review", status="inProgress", turn="child-turn"
    ):
        payload = {
            "threadId": child,
            "turnId": turn,
            "reviewId": review_id,
            "targetItemId": "command",
            "startedAtMs": 1000,
            "action": {
                "type": "command",
                "command": "echo harmless",
                "cwd": "/tmp",
                "source": "shell",
            },
            "review": {"status": status, "rationale": f"Native {status}"},
        }
        if status != "inProgress":
            payload.update(completedAtMs=2000, decisionSource="agent")
        await self.send(
            "item/autoApprovalReview/started"
            if status == "inProgress"
            else "item/autoApprovalReview/completed",
            payload,
        )

    async def warning(self, child="child", message="Native warning"):
        await self.send("guardianWarning", {"threadId": child, "message": message})


class FakeHarness:
    def __init__(self):
        self.connections: list[FakeConnection] = []
        self.model = "provider/model"
        self.permission_defaults: JsonObject = {
            "approvalPolicy": "on-request",
            "approvalsReviewer": "user",
            "sandbox": {"type": "workspaceWrite"},
            "activePermissionProfile": {"id": ":workspace"},
        }
        self.configurations = {self.model: "capabilities-1"}
        self.context_windows: dict[str, int | None] = {self.model: None}
        self.efforts = ("off", "low", "medium", "high", "xhigh", "max")
        self.default_effort = "medium"
        self.creation_gate = asyncio.Event()
        self.start_gate = asyncio.Event()
        self.creation_gate.set()
        self.start_gate.set()
        self.creating = asyncio.Event()
        self.started = asyncio.Event()
        self.submitted = asyncio.Event()
        self.interrupted = asyncio.Event()
        self.input_changed = asyncio.Event()
        self.answer_gate = asyncio.Event()
        self.answer_gate.set()
        self.answering = asyncio.Event()
        self.answered = asyncio.Event()
        self.interrupt_gate = asyncio.Event()
        self.interrupt_gate.set()
        self.turn_count = 0
        self.histories: dict[str, list[ItemUpdate]] = {}
        self.delete_error: Exception | None = None
        self.delete_gate = asyncio.Event()
        self.delete_gate.set()
        self.deleting = asyncio.Event()
        self.delete_before_error = False

    def availability(self):
        return True, None

    def catalog(self):
        return CodeCatalog(
            self.model,
            tuple(
                CodeModel(
                    id=model,
                    display_name=model,
                    provider_id=split_provider_model_ref(model)[0],
                    model_name=split_provider_model_ref(model)[1],
                    reasoning_efforts=self.efforts,
                    default_reasoning_effort=self.default_effort,
                    context_window_tokens=self.context_windows.get(model),
                )
                for model in self.configurations
            ),
        )

    async def prepare(self, model, reasoning_effort, mode):
        if model not in self.configurations:
            raise CodeValidationError("This model is unavailable.")
        if reasoning_effort is not None and reasoning_effort not in self.efforts:
            raise CodeValidationError("This reasoning effort is unavailable.")
        return FakeSelection(
            self,
            model,
            self.configurations[model],
            dict(self.configurations),
            reasoning_effort or self.default_effort,
            mode,
        )

    async def open_history(self, cwd: str, sink: EventSink):
        return await (await self.prepare(self.model, None, "config")).open(cwd, sink)

    async def wait_inputs(self, count: int):
        while sum(len(connection.inputs) for connection in self.connections) < count:
            self.input_changed.clear()
            await self.input_changed.wait()


@dataclass
class FakeSelection:
    harness: FakeHarness
    model: str
    configuration_key: str
    catalog: dict[str, str]
    reasoning_effort: str | None
    mode: CodeMode

    async def open(self, cwd: str, sink: EventSink):
        connection = FakeConnection(self.harness, sink, self.catalog)
        self.harness.connections.append(connection)
        return connection


class FakeConnection:
    def __init__(self, harness: FakeHarness, sink: EventSink, catalog: dict[str, str]):
        self.harness = harness
        self.sink = sink
        self.catalog = catalog
        self.generation = str(uuid.uuid4())
        self.thread_id: str | None = None
        self.inputs: list[tuple[str, str, str]] = []
        self.efforts: list[str | None] = []
        self.modes: list[CodeMode] = []
        self.defaults: list[JsonObject] = []
        self.interrupts: list[str] = []
        self.deleted: list[str] = []
        self.resumed: list[str] = []
        self.answers: list[tuple[str | int, JsonObject]] = []
        self.requests: dict[str | int, PromptRequest] = {}
        self.closed = False

    def supports(self, selection: HarnessSelection):
        return (
            not self.closed
            and self.catalog.get(selection.model) == selection.configuration_key
        )

    async def create_thread(self):
        self.harness.creating.set()
        await self.harness.creation_gate.wait()
        if self.closed:
            raise CodeUnavailableError("Native process closed during creation.")
        self.thread_id = f"native-{len(self.harness.histories) + 1}"
        self.harness.histories[self.thread_id] = []
        return NativeThread(
            self.thread_id, permission_defaults=self.harness.permission_defaults
        )

    async def resume_thread(self, thread_id: str):
        self.resumed.append(thread_id)
        self.thread_id = thread_id
        return await self.read_thread(thread_id)

    async def read_thread(self, thread_id: str):
        if thread_id not in self.harness.histories:
            raise NativeHistoryMissing("Native conversation not found.")
        groups: dict[str, list[ItemUpdate]] = {}
        for item in self.harness.histories[thread_id]:
            groups.setdefault(item.turn_id, []).append(item)
        return NativeThread(
            thread_id,
            tuple(
                NativeTurn(turn_id, tuple(items)) for turn_id, items in groups.items()
            ),
            self.harness.permission_defaults,
        )

    async def start_turn(
        self,
        text: str,
        selection: HarnessSelection,
        client_id: str,
        permission_defaults: JsonObject,
    ):
        self.inputs.append((client_id, text, selection.model))
        self.efforts.append(selection.reasoning_effort)
        self.modes.append(selection.mode)
        self.defaults.append(permission_defaults)
        self.harness.input_changed.set()
        self.harness.submitted.set()
        self.harness.turn_count += 1
        turn_id = f"turn-{self.harness.turn_count}"
        await self.harness.start_gate.wait()
        if self.closed:
            raise CodeUnavailableError("Native process closed during submission.")
        await self.sink(
            HarnessEvent(
                self.generation, self.thread_id, "turn_started", turn_id=turn_id
            )
        )
        self.harness.started.set()
        return turn_id

    async def interrupt(self, turn_id: str):
        self.interrupts.append(turn_id)
        self.harness.interrupted.set()
        await self.harness.interrupt_gate.wait()
        if self.closed:
            raise CodeUnavailableError(
                "Native process closed before interrupt acknowledgement."
            )
        await self.finish(turn_id, "interrupted")

    async def finish(self, turn_id: str, status: RunStatus = "completed", message=None):
        await self.sink(
            HarnessEvent(
                self.generation,
                self.thread_id,
                "turn_completed",
                turn_id=turn_id,
                status=status,
                message=message,
            )
        )

    async def text(
        self, turn_id: str, item_id: str, text: str, *, complete=False, kind="text"
    ):
        item = ItemUpdate(
            turn_id,
            item_id,
            kind,
            text=text,
            complete=complete,
            raw={"id": item_id, "text": text},
        )
        if self.thread_id:
            self.harness.histories[self.thread_id].append(item)
        await self.sink(
            HarnessEvent(
                self.generation, self.thread_id, "item", turn_id=turn_id, item=item
            )
        )

    async def context_usage(
        self,
        turn_id: str,
        used_tokens: int,
        *,
        thread_id: str | None = None,
        generation: str | None = None,
    ):
        await self.sink(
            HarnessEvent(
                generation or self.generation,
                self.thread_id if thread_id is None else thread_id,
                "context_usage",
                turn_id=turn_id,
                context_used_tokens=used_tokens,
            )
        )

    async def prompt(self, request_id: str | int, turn_id: str | None = "turn-1"):
        prompt = PromptRequest(
            request_id,
            "approval",
            {
                "title": "Run command?",
                "choices": [
                    {"id": "accept", "label": "Allow"},
                    {"id": "decline", "label": "Decline"},
                ],
            },
            {"requestId": request_id},
            turn_id,
        )
        self.requests[request_id] = prompt
        await self.sink(
            HarnessEvent(
                self.generation,
                self.thread_id,
                "prompt",
                turn_id=turn_id,
                prompt=prompt,
            )
        )

    def prepare_answer(self, request_id: str | int, answer: JsonObject):
        if request_id not in self.requests:
            raise CodeConflictError("Prompt resolved.")
        return dict(answer)

    async def respond(self, request_id: str | int, response: JsonObject):
        self.harness.answering.set()
        await self.harness.answer_gate.wait()
        try:
            if request_id not in self.requests:
                raise CodeConflictError("Prompt resolved.")
            self.answers.append((request_id, response))
            await self.resolve(request_id)
        finally:
            self.harness.answered.set()

    async def resolve(self, request_id: str | int):
        self.requests.pop(request_id, None)
        await self.sink(
            HarnessEvent(
                self.generation, self.thread_id, "resolved", request_id=request_id
            )
        )

    async def delete_thread(self, thread_id: str):
        self.deleted.append(thread_id)
        self.harness.deleting.set()
        await self.harness.delete_gate.wait()
        if self.harness.delete_before_error:
            self.harness.histories.pop(thread_id, None)
        if self.harness.delete_error:
            raise self.harness.delete_error
        self.harness.histories.pop(thread_id, None)

    async def close(self):
        if self.closed:
            return
        self.closed = True
        self.harness.creation_gate.set()
        self.harness.start_gate.set()
        self.harness.answer_gate.set()
        self.harness.interrupt_gate.set()
        self.harness.delete_gate.set()
        await self.sink(HarnessEvent(self.generation, self.thread_id, "closed"))


async def close_code_database(service):
    """Tests composing a service directly also own its injected database."""
    from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore

    assert isinstance(service._store, SQLiteCodeStore)
    await service._store.database.close()