@mseep/open-computer-use 1.0.0

package/tests/test-mcp-native-surface.sh

@@ -0,0 +1,213 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+#
+# Smoke tests for the six MCP-native system-prompt delivery tiers.
+# Hits a LIVE computer-use-server on http://localhost:8081 and walks every
+# channel end-to-end (curl only — no Python client dependency).
+#
+# Usage:
+#   docker compose up --build -d computer-use-server
+#   ./tests/test-mcp-native-surface.sh [server-url]
+#
+# Default server URL: http://localhost:8081
+#
+# Requires: docker, curl, jq
+
+set -euo pipefail
+
+SERVER_URL="${1:-http://localhost:8081}"
+PASSED=0
+FAILED=0
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+pass() { echo -e "  ${GREEN}PASS${NC}: $1"; PASSED=$((PASSED + 1)); }
+fail() { echo -e "  ${RED}FAIL${NC}: $1"; FAILED=$((FAILED + 1)); }
+skip() { echo -e "  ${YELLOW}SKIP${NC}: $1"; }
+
+banner() { echo ""; echo "=== $1 ==="; }
+
+# ---------------------------------------------------------------------------
+# Pre-flight
+# ---------------------------------------------------------------------------
+
+banner "Pre-flight"
+
+if ! curl -sf "${SERVER_URL}/health" >/dev/null 2>&1; then
+    echo -e "${RED}ERROR${NC}: ${SERVER_URL}/health is unreachable."
+    echo "Start the server first: docker compose up --build -d computer-use-server"
+    exit 1
+fi
+pass "server reachable at ${SERVER_URL}"
+
+# ---------------------------------------------------------------------------
+# Tier 6 — HTTP /system-prompt (the easiest to exercise via curl)
+# ---------------------------------------------------------------------------
+
+banner "Tier 6 — HTTP /system-prompt (header priority + aliases + response header)"
+
+BODY=$(curl -sS "${SERVER_URL}/system-prompt?chat_id=smoke-qry")
+if echo "$BODY" | grep -q "/files/smoke-qry"; then
+    pass "query chat_id substituted into /files/ URL"
+else
+    fail "query chat_id NOT substituted (expected /files/smoke-qry)"
+fi
+
+BODY=$(curl -sS -H "X-Chat-Id: smoke-hdr" "${SERVER_URL}/system-prompt?chat_id=smoke-qry-loses")
+if echo "$BODY" | grep -q "/files/smoke-hdr" && ! echo "$BODY" | grep -q "/files/smoke-qry-loses"; then
+    pass "header wins over query (smoke-hdr present, smoke-qry-loses absent)"
+else
+    fail "header priority broken"
+fi
+
+BODY=$(curl -sS -H "X-OpenWebUI-Chat-Id: smoke-alias" "${SERVER_URL}/system-prompt")
+if echo "$BODY" | grep -q "/files/smoke-alias"; then
+    pass "X-OpenWebUI-Chat-Id alias honored"
+else
+    fail "X-OpenWebUI-Chat-Id alias ignored"
+fi
+
+# X-Public-Base-URL response header present (Open WebUI filter depends on it)
+HDRS=$(curl -sS -D - -o /dev/null "${SERVER_URL}/system-prompt?chat_id=smoke")
+if echo "$HDRS" | grep -qi "^x-public-base-url:"; then
+    pass "X-Public-Base-URL response header emitted"
+else
+    fail "X-Public-Base-URL response header missing (Open WebUI filter will lose public URL)"
+fi
+
+# Foundation: self-identification header first
+BODY=$(curl -sS "${SERVER_URL}/system-prompt?chat_id=smoke-id")
+if echo "$BODY" | grep -q "This is the contents of /home/assistant/README.md"; then
+    pass "rendered prompt carries README.md self-identification header"
+else
+    fail "self-identification header missing — clients won't know the canonical location"
+fi
+
+# ---------------------------------------------------------------------------
+# Tier 2 — README.md in sandbox (requires MCP tool call to create a container)
+# ---------------------------------------------------------------------------
+
+banner "Tier 2 — /home/assistant/README.md in sandbox"
+
+# Look for a sandbox container created AFTER the server process started.
+# Containers from previous sessions predate this commit and will not have
+# README.md — we do not retro-fit existing workspace volumes.
+SERVER_PID=$(docker inspect --format '{{.State.StartedAt}}' computer-use-server 2>/dev/null || echo "")
+CONTAINER=""
+if [ -n "$SERVER_PID" ]; then
+    for c in $(docker ps -q --filter "label=tool=computer-use-mcp"); do
+        CREATED=$(docker inspect --format '{{.Created}}' "$c" 2>/dev/null || echo "")
+        if [ -n "$CREATED" ] && [ "$CREATED" \> "$SERVER_PID" ]; then
+            CONTAINER="$c"
+            break
+        fi
+    done
+fi
+
+if [ -z "$CONTAINER" ]; then
+    skip "no sandbox container newer than computer-use-server startup — trigger an MCP bash_tool call via a real client first (stale pre-refactor containers don't count)"
+else
+    if docker exec "$CONTAINER" cat /home/assistant/README.md 2>/dev/null | grep -q "This is the contents"; then
+        pass "README.md present in container ${CONTAINER}, carries self-id header"
+    elif docker exec "$CONTAINER" test -f /home/assistant/README.md 2>/dev/null; then
+        pass "README.md present in container ${CONTAINER} (header format unknown — review manually)"
+    else
+        fail "README.md not present in container ${CONTAINER} — Tier 2 write failed"
+    fi
+fi
+
+# ---------------------------------------------------------------------------
+# Tier 1 — tool description nudges (depends on MCP tools/list)
+# Tier 3/4 — InitializeResult.instructions (depends on MCP initialize)
+# Tier 5 — resources/list (depends on MCP resources/list)
+#
+# All three need a working MCP JSON-RPC endpoint. There is a pre-existing
+# double-session_manager bug (see PR body) that blocks this path under
+# uvicorn. In-process tests in tests/orchestrator/ cover them:
+#
+#   - test_tool_descriptions.py        (Tier 1)
+#   - test_dynamic_instructions.py     (Tier 4)
+#   - test_mcp_resources.py            (Tier 5)
+#
+# We still probe /mcp here so the smoke suite picks up the day we fix that.
+# ---------------------------------------------------------------------------
+
+banner "Tiers 1/3/4/5 — MCP JSON-RPC probe"
+
+INIT_PAYLOAD='{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"smoke","version":"1.0"}}}'
+
+# Capture both response headers AND body — the streamable-HTTP transport
+# allocates an Mcp-Session-Id on the initialize response, and ALL subsequent
+# JSON-RPC calls on the same logical session must echo that header back.
+# Without it, tools/list / resources/list error out (or worse, silently
+# allocate a fresh session and lose the chat context that initialize set).
+STATUS=$(curl -s -D /tmp/mcp-init.hdrs -o /tmp/mcp-init.out -w '%{http_code}' -X POST "${SERVER_URL}/mcp" \
+    -H 'Content-Type: application/json' \
+    -H 'Accept: application/json, text/event-stream' \
+    -H 'X-Chat-Id: smoke-mcp' \
+    -d "$INIT_PAYLOAD")
+
+# Header name is case-insensitive; normalize to lower for grep, then strip CRLF.
+SESSION_ID=$(grep -i '^mcp-session-id:' /tmp/mcp-init.hdrs | head -1 | cut -d: -f2- | tr -d ' \r\n')
+
+if [ "$STATUS" = "200" ]; then
+    if grep -q '"instructions"' /tmp/mcp-init.out || grep -q 'instructions' /tmp/mcp-init.out; then
+        pass "MCP initialize returned 200 with instructions (Tier 4)"
+    else
+        fail "MCP initialize returned 200 but no 'instructions' field"
+    fi
+
+    if [ -z "$SESSION_ID" ]; then
+        skip "no Mcp-Session-Id header in initialize response — skipping session-bound probes (server may not be in streamable-HTTP mode)"
+    else
+        # tools/list — pass session id so we stay on the same logical session
+        curl -sS -X POST "${SERVER_URL}/mcp" \
+            -H 'Content-Type: application/json' \
+            -H 'Accept: application/json, text/event-stream' \
+            -H 'X-Chat-Id: smoke-mcp' \
+            -H "Mcp-Session-Id: ${SESSION_ID}" \
+            -d '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' > /tmp/mcp-tools.out
+        if grep -q 'README.md' /tmp/mcp-tools.out; then
+            pass "tools/list descriptions mention README.md (Tier 1)"
+        else
+            fail "tools/list descriptions do not mention README.md"
+        fi
+
+        # resources/list — Tier 5 surface for uploaded files. Empty list is OK
+        # for a fresh smoke chat that has no uploads; the test verifies the
+        # method itself works (not an error response).
+        curl -sS -X POST "${SERVER_URL}/mcp" \
+            -H 'Content-Type: application/json' \
+            -H 'Accept: application/json, text/event-stream' \
+            -H 'X-Chat-Id: smoke-mcp' \
+            -H "Mcp-Session-Id: ${SESSION_ID}" \
+            -d '{"jsonrpc":"2.0","id":3,"method":"resources/list","params":{}}' > /tmp/mcp-resources.out
+        if grep -q '"resources"' /tmp/mcp-resources.out && ! grep -q '"error"' /tmp/mcp-resources.out; then
+            pass "resources/list responds without error (Tier 5)"
+        else
+            fail "resources/list errored or returned no resources field"
+        fi
+    fi
+else
+    skip "MCP /mcp endpoint returned ${STATUS} — pre-existing double-session_manager bug (see PR). In-process pytest covers these tiers."
+fi
+
+# ---------------------------------------------------------------------------
+# Summary
+# ---------------------------------------------------------------------------
+
+echo ""
+echo "==============================="
+echo "  PASSED: ${PASSED}"
+echo "  FAILED: ${FAILED}"
+echo ""
+
+if [ "$FAILED" -gt 0 ]; then
+    echo -e "  ${RED}RESULT: FAILED${NC}"
+    exit 1
+fi
+echo -e "  ${GREEN}RESULT: ALL CLEAN${NC}"

package/tests/test-no-cyrillic.sh

@@ -0,0 +1,135 @@
+#!/bin/bash
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+# Test: No Cyrillic characters in repository source/docs.
+#
+# Repo policy (CLAUDE.md): English-only. No exceptions.
+#
+# Usage: ./tests/test-no-cyrillic.sh [project-root]
+# Exit code: 0 = clean, 1 = Cyrillic found
+
+set -euo pipefail
+
+ROOT="${1:-$(cd "$(dirname "$0")/.." && pwd)}"
+
+cd "$ROOT"
+
+echo "=== Testing: No Cyrillic characters in $ROOT ==="
+echo ""
+
+# Use Python for portable Unicode regex (BSD grep on macOS has no PCRE,
+# and CI runs on Ubuntu — keep one impl).
+python3 - <<'PY'
+import os, re, subprocess, sys
+
+CYR = re.compile(r'[Ѐ-ӿ]')
+
+# Denylist approach: scan EVERY tracked text file. The previous extensions
+# allowlist let Cyrillic slip in via unlisted extensions (e.g. `.txt`,
+# `.cfg`, `.env.example`). Skip only known-binary extensions, vendored
+# trees, and the explicit self-reference below.
+SKIP_DIR_PREFIXES = (
+    '.git/', '.venv/', '.venv-itest/', '.venv-review/',
+    'node_modules/', '__pycache__/', '.claude/', '.planning/',
+    'dist/', 'build/',
+)
+SKIP_FILES = {
+    'tests/test-no-cyrillic.sh',
+}
+# Binary / generated extensions. Avoid scanning these for both performance
+# and to prevent false positives on encoded payloads.
+BINARY_EXTS = {
+    '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.svg',
+    '.pdf', '.zip', '.tar', '.gz', '.bz2', '.xz', '.7z',
+    '.woff', '.woff2', '.ttf', '.otf', '.eot',
+    '.mp3', '.mp4', '.mov', '.avi', '.webm', '.ogg', '.wav',
+    '.so', '.dylib', '.dll', '.exe', '.bin', '.o', '.a',
+    '.pyc', '.pyo', '.class', '.jar',
+    '.lock', '.min.js', '.min.css',
+}
+SKIP_BASENAMES = {'locale.js'}
+
+def listed_files():
+    """All files tracked by git, excluding deletions. Falls back to a
+    plain os.walk if git is unavailable (e.g. tarball checkout)."""
+    try:
+        out = subprocess.check_output(
+            ['git', 'ls-files', '-z'], stderr=subprocess.DEVNULL,
+        )
+        return [p for p in out.decode('utf-8', errors='replace').split('\0') if p]
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        files = []
+        for dirpath, dirnames, filenames in os.walk('.'):
+            rel = dirpath[2:] + '/' if dirpath.startswith('./') else dirpath + '/'
+            dirnames[:] = [
+                d for d in dirnames
+                if not any((rel + d + '/').startswith(p) for p in SKIP_DIR_PREFIXES)
+            ]
+            for name in filenames:
+                files.append(os.path.normpath(os.path.join(dirpath, name)))
+        return files
+
+def included(path):
+    if path in SKIP_FILES:
+        return False
+    if any(path.startswith(p) for p in SKIP_DIR_PREFIXES):
+        return False
+    name = os.path.basename(path)
+    if name in SKIP_BASENAMES:
+        return False
+    lower = name.lower()
+    for ext in BINARY_EXTS:
+        if lower.endswith(ext):
+            return False
+    return True
+
+def is_text(path, sniff_bytes=8192):
+    """A file is text if it has no NUL byte and decodes cleanly as UTF-8.
+    Cheap heuristic, good enough for source-tree scanning."""
+    try:
+        with open(path, 'rb') as f:
+            chunk = f.read(sniff_bytes)
+    except OSError:
+        return False
+    if b'\x00' in chunk:
+        return False
+    try:
+        chunk.decode('utf-8')
+    except UnicodeDecodeError:
+        return False
+    return True
+
+bad = []
+for path in listed_files():
+    if not os.path.isfile(path):
+        continue
+    if not included(path):
+        continue
+    if not is_text(path):
+        continue
+    try:
+        with open(path, 'r', encoding='utf-8', errors='replace') as f:
+            for lineno, line in enumerate(f, 1):
+                if CYR.search(line):
+                    bad.append((path, lineno, line.rstrip()))
+    except OSError:
+        continue
+
+if not bad:
+    print("  PASS: no Cyrillic found")
+    print("")
+    print("=== Test passed ===")
+    sys.exit(0)
+
+print(f"  FAIL: {len(bad)} line(s) contain Cyrillic characters\n")
+print("Offending lines (path:line:content):")
+for path, lineno, line in bad[:50]:
+    print(f"    {path}:{lineno}:{line}")
+if len(bad) > 50:
+    print(f"    ... and {len(bad) - 50} more")
+print("")
+print("Policy (CLAUDE.md): repo is English-only. Rewrite affected lines.")
+print("")
+print("=== Test FAILED ===")
+sys.exit(1)
+PY

package/tests/test-opencode-error-mapping.py

@@ -0,0 +1,130 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""Unit tests for opencode adapter error event mapping (REQ-MCP-03).
+
+These tests verify that the opencode adapter correctly handles
+{"type":"error","data":{...}} events in the NDJSON event stream,
+even when the subprocess exits with rc=0.
+"""
+
+import json
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "computer-use-server"))
+
+import pytest
+from cli_adapters.opencode import OpenCodeAdapter
+
+
+@pytest.fixture
+def adapter():
+    return OpenCodeAdapter()
+
+
+def make_ndjson(*events):
+    """Encode a list of event dicts as NDJSON."""
+    return "\n".join(json.dumps(e) for e in events) + "\n"
+
+
+class TestErrorEventMapping:
+    """Test that et == 'error' events promote is_error and surface the message."""
+
+    def test_error_event_with_message_rc0(self, adapter):
+        """NDJSON with error event + rc=0 -> is_error=True, message surfaced."""
+        ndjson = make_ndjson({"type": "error", "data": {"message": "OAuth expired"}})
+        result = adapter.parse_result(stdout=ndjson, stderr="", returncode=0)
+        assert result.is_error is True, f"is_error should be True, got {result.is_error}"
+        assert "opencode error: OAuth expired" in result.text, (
+            f"text should contain 'opencode error: OAuth expired', got: {result.text!r}"
+        )
+
+    def test_error_event_raw_ndjson_not_in_text(self, adapter):
+        """When error event is present, raw NDJSON must not appear in result text."""
+        ndjson = make_ndjson({"type": "error", "data": {"message": "OAuth expired"}})
+        result = adapter.parse_result(stdout=ndjson, stderr="", returncode=0)
+        # Result text must not be the raw NDJSON dump
+        assert result.text != ndjson.strip(), (
+            f"result.text must not be raw NDJSON, got: {result.text!r}"
+        )
+        # Must not contain '{"type"' (raw event structure)
+        assert '{"type": "error"' not in result.text, (
+            f"raw NDJSON event should not appear in result text: {result.text!r}"
+        )
+
+    def test_error_event_data_null(self, adapter):
+        """NDJSON with error event and data=null -> is_error=True, no exception."""
+        ndjson = make_ndjson({"type": "error", "data": None})
+        result = adapter.parse_result(stdout=ndjson, stderr="", returncode=0)
+        assert result.is_error is True, f"is_error should be True, got {result.is_error}"
+        # Must not raise; text should contain something sensible
+        assert "opencode error:" in result.text, (
+            f"text should start with 'opencode error:', got: {result.text!r}"
+        )
+
+    def test_error_event_no_data_key(self, adapter):
+        """NDJSON with error event and no 'data' key -> is_error=True, fallback to str({})."""
+        ndjson = make_ndjson({"type": "error"})
+        result = adapter.parse_result(stdout=ndjson, stderr="", returncode=0)
+        assert result.is_error is True, f"is_error should be True, got {result.is_error}"
+        assert "opencode error:" in result.text, (
+            f"text should start with 'opencode error:', got: {result.text!r}"
+        )
+
+    def test_error_event_data_no_message_key(self, adapter):
+        """NDJSON with error event and data with no 'message' key -> str(data) fallback."""
+        ndjson = make_ndjson({"type": "error", "data": {"code": 429}})
+        result = adapter.parse_result(stdout=ndjson, stderr="", returncode=0)
+        assert result.is_error is True, f"is_error should be True, got {result.is_error}"
+        assert "opencode error:" in result.text, (
+            f"text should start with 'opencode error:', got: {result.text!r}"
+        )
+        # Should include the code value via str() fallback
+        assert "429" in result.text, (
+            f"str fallback should include code 429, got: {result.text!r}"
+        )
+
+    def test_no_error_events_rc0(self, adapter):
+        """NDJSON with no error events + rc=0 -> is_error=False (existing behavior preserved)."""
+        ndjson = make_ndjson(
+            {"type": "message-completed", "text": "Done successfully"}
+        )
+        result = adapter.parse_result(stdout=ndjson, stderr="", returncode=0)
+        assert result.is_error is False, (
+            f"is_error should be False for success path, got {result.is_error}"
+        )
+        assert result.text == "Done successfully", (
+            f"text should be the success message, got: {result.text!r}"
+        )
+
+    def test_no_events_rc1_still_error(self, adapter):
+        """NDJSON with no events + rc=1 -> is_error=True (rc-based init still works)."""
+        result = adapter.parse_result(stdout="", stderr="some error", returncode=1)
+        assert result.is_error is True, (
+            f"is_error should be True for rc=1, got {result.is_error}"
+        )
+
+
+class TestErrorEventDoesNotCorruptSuccessPath:
+    """Verify that adding the error branch does not break existing event handlers."""
+
+    def test_step_finish_cost_extraction_still_works(self, adapter):
+        """step-finish cost extraction unaffected by error branch addition."""
+        ndjson = make_ndjson(
+            {"type": "step-finish", "text": "Step done", "cost": 0.005},
+        )
+        result = adapter.parse_result(stdout=ndjson, stderr="", returncode=0)
+        assert result.cost_usd == pytest.approx(0.005), (
+            f"cost_usd should be 0.005, got {result.cost_usd}"
+        )
+
+    def test_assistant_message_completed_text_extraction(self, adapter):
+        """assistant-message-completed text extraction unaffected."""
+        ndjson = make_ndjson(
+            {"type": "assistant-message-completed", "text": "Final answer"}
+        )
+        result = adapter.parse_result(stdout=ndjson, stderr="", returncode=0)
+        assert result.text == "Final answer", (
+            f"text should be 'Final answer', got: {result.text!r}"
+        )
+        assert result.is_error is False