@mseep/open-computer-use 1.0.0

package/computer-use-server/cli_adapters/claude.py

@@ -0,0 +1,163 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""Claude Code CLI adapter — byte-identical lift of mcp_tools.py.
+
+LIFTED FROM (verbatim, no logic changes):
+  - mcp_tools.py:812-857  → parse_result(...)  [JSON-line parser]
+  - mcp_tools.py:967-1019 → build_argv(...)    [argv builder, two branches]
+
+DORMANT in Phase 4: mcp_tools.sub_agent does NOT call this adapter yet.
+The production path stays in mcp_tools.sub_agent through Phase 6 (success
+criterion #4: "MCP sub_agent tool signature and behaviour are unchanged
+in this phase"). Phase 7 flips dispatch through cli_runtime.
+
+The byte-identicality of build_argv vs the v0.9.2.0 production code is
+verified by tests/orchestrator/test_subagent_claude_compat.py (golden
+snapshot, plan 04-04). The argv layer is what is asserted byte-identical;
+the surrounding `cd <wd> && <headers_env> ...` shell-execution wrapper
+stays in mcp_tools.sub_agent (RESEARCH.md note at line 215).
+"""
+
+import json
+
+from .result import SubAgentResult
+
+
+class ClaudeAdapter:
+    """Adapter for the `claude` CLI (Anthropic Claude Code).
+
+    Does NOT inherit from CliAdapter — structural typing via typing.Protocol
+    is sufficient (RESEARCH.md lines 244-260).
+    """
+
+    def build_argv(
+        self,
+        task: str,
+        system_prompt: str,
+        model: str,
+        max_turns: int,
+        timeout_s: int,
+        *,
+        resume_session_id: str = "",
+        plan_file: str = "",
+    ) -> list[str]:
+        """Return the argv list for invoking `claude --print ...`.
+
+        Two branches (lifted from mcp_tools.py:962-1019):
+          - RESUME: when resume_session_id is non-empty, build the resume argv.
+          - NEW SESSION: otherwise, build the new-session argv with --model
+            and --append-system-prompt.
+
+        Common flags appended to BOTH branches (lifted from mcp_tools.py:954-959):
+          --max-turns N --permission-mode bypassPermissions
+          --disallowedTools AskUserQuestion,ExitPlanMode --output-format json
+
+        Note: timeout_s is part of the Protocol but not consumed here — the
+        existing v0.9.2.0 invocation enforces timeout via the asyncio wrapper
+        in mcp_tools.sub_agent, NOT via a CLI flag. Accepted for Protocol
+        uniformity; codex/opencode adapters will use it.
+
+        Note: plan_file is part of the Protocol but not consumed here — the
+        short-prompt construction (`Read and execute your task plan from
+        <plan_file>`) lives in mcp_tools.sub_agent today and is passed in as
+        `task`. Accepted for Protocol uniformity.
+        """
+        common = [
+            "--max-turns", str(max_turns),
+            "--permission-mode", "bypassPermissions",
+            "--disallowedTools", "AskUserQuestion,ExitPlanMode",
+            "--output-format", "json",
+        ]
+
+        if resume_session_id:
+            # RESUME branch (lifted from mcp_tools.py:962-973)
+            return [
+                "claude",
+                "-p", task,
+                "--resume", resume_session_id,
+                *common,
+            ]
+
+        # NEW SESSION branch (lifted from mcp_tools.py:974-1019)
+        return [
+            "claude",
+            "-p", task,
+            "--model", model,
+            "--append-system-prompt", system_prompt,
+            *common,
+        ]
+
+    def parse_result(
+        self,
+        stdout: str,
+        stderr: str,
+        returncode: int,
+    ) -> SubAgentResult:
+        """Parse Claude's `--output-format json` stream.
+
+        Body lifted verbatim from mcp_tools.py:_format_sub_agent_result
+        (lines 819-845). Tail (lines 847-855) is REMOVED here — string
+        formatting belongs to a future render layer (Phase 7 concern), not
+        the parser. Returns SubAgentResult instead.
+
+        cost_usd → None when total_cost_usd is 0.0 OR missing (per Pitfall 4:
+        render "cost: unavailable" rather than "$0.00" upstream).
+        turns → None when num_turns is 0 OR missing (same rationale).
+        session_id → None when empty string OR missing.
+
+        is_error → True when the JSON `result` line says is_error=True OR when
+        returncode != 0. The returncode gate aligns ClaudeAdapter with
+        CodexAdapter/OpenCodeAdapter (Phase 5 BLOCKER 1) — without it, killed
+        or timed-out claude runs (rc=137/143/124 with empty stdout) would
+        silently render as success because there is no JSON `result` line to
+        flip is_error.
+
+        returncode → captured into SubAgentResult.returncode (added in plan
+        05-02 Task 0) so the caller can render distinct user-facing messages
+        for rc=124 (timeout), rc=137 (SIGKILL), rc=143 (SIGTERM).
+        """
+        response_text = ""
+        cost = 0.0
+        turns = 0
+        is_error = False
+        session_id = ""
+
+        try:
+            for line in stdout.strip().split("\n"):
+                line = line.strip()
+                if '"type"' in line and '"result"' in line:
+                    try:
+                        parsed = json.loads(line)
+                        if parsed.get("type") == "result":
+                            response_text = parsed.get("result", "")
+                            cost = parsed.get("total_cost_usd", 0.0)
+                            turns = parsed.get("num_turns", 0)
+                            is_error = parsed.get("is_error", False)
+                            session_id = parsed.get("session_id", "")
+                            break
+                    except json.JSONDecodeError:
+                        continue
+        except Exception as e:
+            # Preserve operator-visible diagnostic from the original
+            # _format_sub_agent_result (line 842).
+            print(f"[SUB-AGENT] Failed to parse JSON output: {e}")
+
+        if not response_text:
+            response_text = stdout
+
+        # BLOCKER 1: align with CodexAdapter/OpenCodeAdapter — non-zero rc is
+        # ALWAYS an error, even when the JSON `result` line is missing
+        # (killed/SIGKILL/SIGTERM/timeout cases). Without this gate,
+        # rc=137 + empty stdout would silently produce is_error=False and
+        # mcp_tools' Sub-Agent-Terminated branch would never fire.
+        is_error = is_error or (returncode != 0)
+
+        return SubAgentResult(
+            text=response_text,
+            cost_usd=cost if cost else None,
+            turns=turns if turns else None,
+            is_error=is_error,
+            session_id=session_id or None,
+            raw_events=[],
+            returncode=returncode,
+        )

package/computer-use-server/cli_adapters/codex.py

@@ -0,0 +1,163 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""Codex CLI adapter (ADAPT-03) — Phase 5 implementation.
+
+Invokes `codex exec --ephemeral --json --output-last-message <tmpfile> ...`
+with --full-auto (NOT --dangerously-bypass-approvals-and-sandbox per
+PITFALLS.md anti-pattern table). Justification for --full-auto: we run
+inside an isolated Docker container that already provides the sandbox
+boundary that codex's own approval layer would otherwise enforce.
+
+System-prompt injection is via concatenation into the prompt argument
+("<system_prompt>\\n\\n---\\n\\n<task>") — codex 0.125.0 has no
+--append-system-prompt / --system flag (Pitfall 2 in PITFALLS.md).
+
+The /tmp/codex-agents-<uuid> workdir is created by cli_runtime.dispatch
+BEFORE invocation (codex requires --cd to point at an existing dir).
+Adapter stays a pure function — no side effects.
+
+cost_usd is always None — codex JSONL stream does not surface a USD cost
+(Pitfall 4: render "unavailable" upstream, not "$0.00").
+
+parse_result populates SubAgentResult.returncode with the passed-in
+returncode so plan 05-05's mcp_tools error-rendering branch can switch
+on it (rc=124 timeout, rc=137 SIGKILL, rc=143 SIGTERM, default non-zero
+"failed with exit code N").
+"""
+
+import json
+import uuid
+
+from .result import SubAgentResult
+
+
+class CodexAdapter:
+    """Adapter for the `codex` CLI (@openai/codex 0.125.0).
+
+    Does NOT inherit from CliAdapter — structural typing via typing.Protocol
+    is sufficient (matches ClaudeAdapter pattern).
+    """
+
+    def build_argv(
+        self,
+        task: str,
+        system_prompt: str,
+        model: str,
+        max_turns: int,
+        timeout_s: int,
+        *,
+        resume_session_id: str = "",
+        plan_file: str = "",
+    ) -> list[str]:
+        """Return argv for `codex exec --ephemeral --json ...`.
+
+        Notes:
+          - max_turns is NOT honored by codex CLI (Claude-only flag); the
+            SUB_AGENT_TIMEOUT backstop is the caller's responsibility
+            (Pitfall 5 — codex turn-counting is a Phase 7 followup).
+          - resume_session_id is IGNORED with informational stderr warning
+            (codex --ephemeral is stateless by design; documented in
+            Phase 8 docs).
+          - plan_file is part of the Protocol but not consumed here — the
+            short-prompt construction (`Read and execute your task plan ...`)
+            is built by mcp_tools.sub_agent and passed in as `task`, same
+            as ClaudeAdapter.
+        """
+        workdir = f"/tmp/codex-agents-{uuid.uuid4().hex[:12]}"
+        last_msg_file = f"{workdir}/last_message.txt"
+
+        # Pitfall 2: codex has no --append-system-prompt; concatenate as
+        # task preamble. Empty system_prompt => task only.
+        combined_prompt = (
+            f"{system_prompt}\n\n---\n\n{task}" if system_prompt else task
+        )
+
+        if resume_session_id:
+            # Inform the operator (stderr) that codex --ephemeral cannot
+            # honor session resume. We do NOT raise — caller may have
+            # supplied resume_session_id from a previous claude run; we
+            # gracefully start a fresh ephemeral session.
+            import sys
+            print(
+                f"[codex-adapter] WARNING: resume_session_id={resume_session_id!r} "
+                f"ignored — codex --ephemeral is stateless.",
+                file=sys.stderr,
+            )
+
+        return [
+            "codex", "exec",
+            "--ephemeral",
+            "--json",
+            "--output-last-message", last_msg_file,
+            "--model", model,
+            "--full-auto",
+            "--cd", workdir,
+            "--skip-git-repo-check",
+            combined_prompt,
+        ]
+
+    def parse_result(
+        self,
+        stdout: str,
+        stderr: str,
+        returncode: int,
+    ) -> SubAgentResult:
+        """Parse codex's `--json` JSONL event stream.
+
+        Schema (developers.openai.com/codex/noninteractive):
+          - turn.started / turn.completed (with usage.input_tokens / output_tokens)
+          - item.completed where item.type == "message" carries the
+            assistant text in item.content[].text
+
+        cost_usd is always None (Pitfall 4): codex doesn't surface USD
+        cost in the stream; computing it would require a per-model price
+        table (deferred to v0.9.x).
+
+        turns is None (codex's turn.completed is per-turn, not cumulative
+        count; we do not maintain a counter here).
+
+        session_id is None (--ephemeral runs have no session id).
+
+        returncode is captured into SubAgentResult.returncode so the
+        caller (plan 05-05) can render distinct user-facing messages for
+        rc=124/137/143/non-zero.
+        """
+        events: list[dict] = []
+        last_message_text = ""
+        tokens_in = 0
+        tokens_out = 0
+        is_error = (returncode != 0)
+
+        for line in stdout.strip().split("\n"):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                event = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            events.append(event)
+            et = event.get("type", "")
+            if et == "item.completed":
+                item = event.get("item", {})
+                if item.get("type") == "message":
+                    for block in item.get("content", []) or []:
+                        if isinstance(block, dict) and block.get("type") == "text":
+                            last_message_text = block.get("text", last_message_text)
+            if et == "turn.completed":
+                usage = event.get("usage", {}) or {}
+                tokens_in += usage.get("input_tokens", 0) or 0
+                tokens_out += usage.get("output_tokens", 0) or 0
+
+        # If codex exits early with no parseable message AND no stdout, fall back
+        # to stderr so the caller surfaces the real CLI error instead of a generic
+        # "failed with exit code N" banner. Per CodeRabbit PR#75 review.
+        return SubAgentResult(
+            text=last_message_text or stdout or stderr,
+            cost_usd=None,
+            turns=None,
+            is_error=is_error,
+            session_id=None,
+            raw_events=events,
+            returncode=returncode,
+        )

package/computer-use-server/cli_adapters/opencode.py

@@ -0,0 +1,169 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""OpenCode CLI adapter (ADAPT-04) — Phase 5 implementation.
+
+Invokes `opencode run "<prompt>" --model <provider/model> --format json
+--dangerously-skip-permissions`. Justification for
+--dangerously-skip-permissions: we run inside an isolated Docker sandbox
+container; the CLI's own permission layer is redundant inside that
+boundary (same rationale as codex --full-auto in cli_adapters/codex.py).
+
+System-prompt injection is via concatenation into the prompt argument
+("<system_prompt>\\n\\n---\\n\\n<task>") — opencode's per-mode system
+prompt lives in the rendered config (Phase 6 concern), not on the CLI
+(Pitfall 2 in PITFALLS.md).
+
+Model MUST be in `provider/model` form (e.g. anthropic/claude-sonnet-4-6,
+openrouter/qwen/qwen-3-coder). cli_runtime.resolve_subagent_model
+expands single-word aliases ("sonnet" -> "anthropic/claude-sonnet-4-6")
+before reaching this adapter; bare ids without a "/" prefix get a
+runtime warning from the resolver.
+
+cost_usd may be a float (when opencode's provider reports per-step cost)
+or None (when not). Pitfall 4: caller renders None as "unavailable",
+not "$0.00".
+
+parse_result populates SubAgentResult.returncode with the passed-in
+returncode so plan 05-05's mcp_tools error-rendering branch can switch
+on it (rc=124 timeout, rc=137 SIGKILL, rc=143 SIGTERM, default non-zero
+"failed with exit code N").
+"""
+
+import json
+
+from .result import SubAgentResult
+
+
+class OpenCodeAdapter:
+    """Adapter for the `opencode` CLI (sst/opencode-ai 1.14.25)."""
+
+    def build_argv(
+        self,
+        task: str,
+        system_prompt: str,
+        model: str,
+        max_turns: int,
+        timeout_s: int,
+        *,
+        resume_session_id: str = "",
+        plan_file: str = "",
+    ) -> list[str]:
+        """Return argv for `opencode run <prompt> --model ... --format json ...`.
+
+        Notes:
+          - max_turns is NOT honored by opencode CLI (Claude-only flag);
+            SUB_AGENT_TIMEOUT is the backstop (Pitfall 5).
+          - resume_session_id is IGNORED with informational stderr warning;
+            opencode `run --continue` requires a per-mode session config
+            that we do not ship until Phase 6.
+          - plan_file is part of the Protocol but not consumed here.
+        """
+        # Pitfall 2: opencode has no CLI flag for system prompt; concatenate
+        # as task preamble (mirrors CodexAdapter shape).
+        combined_prompt = (
+            f"{system_prompt}\n\n---\n\n{task}" if system_prompt else task
+        )
+
+        if resume_session_id:
+            import sys
+            print(
+                f"[opencode-adapter] WARNING: resume_session_id={resume_session_id!r} "
+                f"ignored — opencode run is stateless (Phase 6 will add --continue).",
+                file=sys.stderr,
+            )
+
+        return [
+            "opencode", "run",
+            combined_prompt,
+            "--model", model,
+            "--format", "json",
+            "--dangerously-skip-permissions",
+        ]
+
+    def parse_result(
+        self,
+        stdout: str,
+        stderr: str,
+        returncode: int,
+    ) -> SubAgentResult:
+        """Parse opencode's --format json event stream.
+
+        Schema (opencode.ai/docs/events) varies per provider; the parser is
+        defensive — preserves raw_events for debugging even when the
+        structured fields are missing.
+
+        Recognised final-message event types:
+          - assistant-message-completed
+          - step-finish
+          - message-completed
+
+        Cost: summed from step-finish events when event.cost or
+        event.usage.total_cost is present (numeric). Stays None if no
+        cost-bearing events arrive (e.g. provider doesn't report cost).
+
+        returncode is captured into SubAgentResult.returncode so the
+        caller (plan 05-05) can render distinct messages for rc=124/137/143.
+        """
+        events: list[dict] = []
+        last_message_text = ""
+        cost_usd: float | None = None
+        is_error = (returncode != 0)
+
+        for line in stdout.strip().split("\n"):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                event = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            events.append(event)
+            et = event.get("type", "")
+
+            # Application-level error events (opencode exits rc=0 but emits these).
+            # Must be checked first so the error branch wins over any text extraction
+            # that might otherwise overwrite last_message_text with empty/garbage.
+            if et == "error":
+                is_error = True
+                err_data = event.get("data", {}) or {}
+                if isinstance(err_data, dict):
+                    err_msg = err_data.get("message") or str(err_data)
+                else:
+                    err_msg = str(err_data)
+                last_message_text = f"opencode error: {err_msg}"
+                continue
+
+            # Capture the final assistant text (last seen wins).
+            if et in ("assistant-message-completed", "step-finish", "message-completed"):
+                text_field = (
+                    event.get("text")
+                    or event.get("content")
+                    or event.get("message", {}).get("content")
+                )
+                if isinstance(text_field, str):
+                    last_message_text = text_field
+                elif isinstance(text_field, list):
+                    for block in text_field:
+                        if isinstance(block, dict) and block.get("type") == "text":
+                            last_message_text = block.get("text", last_message_text)
+
+            # Cost aggregation: per-step cost on step-finish.
+            if et == "step-finish":
+                step_cost = event.get("cost")
+                if step_cost is None:
+                    usage = event.get("usage", {}) or {}
+                    step_cost = usage.get("total_cost")
+                if isinstance(step_cost, (int, float)):
+                    cost_usd = (cost_usd or 0.0) + float(step_cost)
+
+        # If opencode exits early with no parseable message AND no stdout, fall
+        # back to stderr (mirrors codex adapter; same CodeRabbit PR#75 review).
+        return SubAgentResult(
+            text=last_message_text or stdout or stderr,
+            cost_usd=cost_usd,
+            turns=None,
+            is_error=is_error,
+            session_id=None,
+            raw_events=events,
+            returncode=returncode,
+        )

package/computer-use-server/cli_adapters/result.py

@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""Normalised sub-agent result type returned by every CLI adapter.
+
+cost_usd is Optional because non-Claude CLIs (codex, opencode) do not
+surface a USD cost in their JSON output (Pitfall 4 in PITFALLS.md).
+None is rendered as "cost: unavailable" in the result string by the
+caller; never as "$0.00" (which would be operator-misleading).
+
+turns and session_id are Optional for the same reason — codex/opencode
+do not emit equivalent fields. The Claude adapter populates them when
+present in the parsed JSON.
+
+raw_events is reserved for future cost computation (model→price tables)
+and debugging; Phase 4 leaves it empty for the Claude adapter.
+
+returncode is the underlying CLI process exit code, captured so the
+caller can render distinct user-facing messages for rc=124 (timeout),
+rc=137 (SIGKILL), rc=143 (SIGTERM) — preserves v0.9.2.0 UX through
+the dispatch refactor.
+"""
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class SubAgentResult:
+    text: str
+    cost_usd: float | None
+    turns: int | None
+    is_error: bool
+    session_id: str | None
+    raw_events: list[dict] = field(default_factory=list)
+    returncode: int = 0