@mseep/open-computer-use 1.0.0

package/tests/orchestrator/test_system_prompt_endpoint.py

@@ -0,0 +1,191 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""Pinning tests for /system-prompt endpoint.
+
+The endpoint at computer-use-server/app.py:1154-1205 is already a correct port
+of the internal fork v3.7/v3.8. These tests pin the current contract so future
+refactors cannot regress it. All tests should PASS on current HEAD.
+
+Run: python -m pytest tests/orchestrator/test_system_prompt_endpoint.py -v
+"""
+
+import sys
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+ROOT = Path(__file__).resolve().parent.parent.parent
+sys.path.insert(0, str(ROOT / "computer-use-server"))
+
+from fastapi.testclient import TestClient  # noqa: E402
+
+import app as app_module  # noqa: E402
+import skill_manager as skill_manager_module  # noqa: E402
+
+
+class SystemPromptEndpointContract(unittest.TestCase):
+    """Pin /system-prompt endpoint behaviour — DO NOT modify the endpoint to make these pass."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.client = TestClient(app_module.app)
+        cls.public_base_url = app_module.PUBLIC_BASE_URL
+
+    def setUp(self):
+        # Ensure tests are hermetic: reset skill_manager memory cache so that
+        # a prior test run (or another test in this file) cannot leak a cached
+        # skill list for the same email. Tests that need an external provider
+        # stub it explicitly below.
+        skill_manager_module._memory_cache.clear()
+
+    def test_chat_id_substitutes_urls_and_literal(self):
+        resp = self.client.get("/system-prompt", params={"chat_id": "abc123"})
+        self.assertEqual(resp.status_code, 200)
+        body = resp.text
+        self.assertIn(f"{self.public_base_url}/files/abc123", body)
+        self.assertIn(f"{self.public_base_url}/files/abc123/archive", body)
+        self.assertIn("abc123", body)
+        self.assertNotIn("{file_base_url}", body)
+        self.assertNotIn("{archive_url}", body)
+        self.assertNotIn("{chat_id}", body)
+
+    def test_user_email_returns_default_skills_when_provider_unconfigured(self):
+        # Hermetic: force _fetch_user_config -> None and _load_user_config_cache -> None
+        # so get_user_skills() takes the DEFAULT_PUBLIC_SKILLS fallback path
+        # regardless of MCP_TOKENS_URL / MCP_TOKENS_API_KEY env state on the host.
+        async def _no_provider(_email):
+            return None
+
+        with patch.object(skill_manager_module, "_fetch_user_config", side_effect=_no_provider), \
+             patch.object(skill_manager_module, "_load_user_config_cache", return_value=None):
+            resp = self.client.get(
+                "/system-prompt",
+                params={"chat_id": "abc", "user_email": "test@example.com"},
+            )
+        self.assertEqual(resp.status_code, 200)
+        self.assertIn("<available_skills>", resp.text)
+        # DEFAULT_PUBLIC_SKILLS must appear — pin a representative one
+        self.assertIn("<name>\ndocx\n</name>", resp.text)
+
+    def test_legacy_file_base_url_extracts_chat_id(self):
+        """
+        Pre-v4.0.0 integrations could pass ?file_base_url=... to embed their
+        own browser-facing URLs in the prompt. Since v4.0.0 the server owns
+        PUBLIC_BASE_URL. We only still accept file_base_url to extract its
+        trailing chat_id for seamless migration. archive_url is ignored —
+        server derives it from PUBLIC_BASE_URL + chat_id.
+        """
+        resp = self.client.get(
+            "/system-prompt",
+            params={
+                "file_base_url": "https://legacy.example.com/files/xyz",
+                "archive_url": "https://legacy.example.com/files/xyz/arch",
+            },
+        )
+        self.assertEqual(resp.status_code, 200)
+        body = resp.text
+        # chat_id extracted from the trailing path segment, URL owned by server.
+        self.assertIn(f"{self.public_base_url}/files/xyz", body)
+        self.assertIn(f"{self.public_base_url}/files/xyz/archive", body)
+        # Neither the legacy host nor the legacy archive URL leaks into the prompt.
+        self.assertNotIn("legacy.example.com", body)
+        # No raw template placeholders.
+        self.assertNotIn("{file_base_url}", body)
+        self.assertNotIn("{archive_url}", body)
+        self.assertNotIn("{chat_id}", body)
+
+    def test_legacy_file_base_url_ignored_when_chat_id_present(self):
+        """Explicit chat_id always wins over legacy file_base_url extraction."""
+        resp = self.client.get(
+            "/system-prompt",
+            params={
+                "chat_id": "winner",
+                "file_base_url": "https://legacy.example.com/files/loser",
+            },
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertIn(f"{self.public_base_url}/files/winner", resp.text)
+        self.assertNotIn("loser", resp.text)
+
+    def test_no_params_returns_unsubstituted_template(self):
+        """Legacy diagnostic path — pre-v4.0.0 external integrators (n8n, custom
+        HTTP callers) hit /system-prompt with no params and substitute the
+        placeholders themselves downstream. Substituting them server-side with a
+        fake "default" chat_id silently feeds those callers URLs they never
+        agreed to. Keep the placeholders intact when no chat_id is provided
+        from any source (header, query, or legacy file_base_url)."""
+        resp = self.client.get("/system-prompt")
+        self.assertEqual(resp.status_code, 200)
+        body = resp.text
+        # At least one placeholder still present — the template wasn't
+        # substituted with a synthetic chat_id.
+        self.assertTrue(
+            any(ph in body for ph in ("{file_base_url}", "{archive_url}", "{chat_id}")),
+            "Expected un-substituted placeholders in no-params response",
+        )
+
+    # ------------------------------------------------------------------
+    # Tier 7 header priority — added in the "maximum native surface" refactor
+    # ------------------------------------------------------------------
+
+    def test_header_overrides_query_chat_id(self):
+        resp = self.client.get(
+            "/system-prompt",
+            params={"chat_id": "qry"},
+            headers={"X-Chat-Id": "hdr"},
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertIn(f"{self.public_base_url}/files/hdr", resp.text)
+        self.assertNotIn("/files/qry", resp.text)
+
+    def test_openwebui_alias_works(self):
+        resp = self.client.get(
+            "/system-prompt",
+            headers={"X-OpenWebUI-Chat-Id": "alias-demo"},
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertIn(f"{self.public_base_url}/files/alias-demo", resp.text)
+
+    def test_header_user_email_overrides_query(self):
+        # Patch the renderer itself so we can assert exactly which user_email
+        # the endpoint forwarded — without this, the assertion only proves
+        # that *some* prompt came back (DEFAULT_PUBLIC_SKILLS appears for
+        # every email), which would silently pass even if header priority
+        # broke and the query value won.
+        captured: dict = {}
+
+        async def _capture(chat_id, user_email):
+            captured["chat_id"] = chat_id
+            captured["user_email"] = user_email
+            return "stub-prompt-body"
+
+        with patch.object(app_module, "render_system_prompt", side_effect=_capture):
+            resp = self.client.get(
+                "/system-prompt",
+                params={"chat_id": "abc", "user_email": "ignored@example.com"},
+                headers={"X-User-Email": "winner@example.com"},
+            )
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(captured.get("user_email"), "winner@example.com")
+
+    def test_content_type_is_text_plain(self):
+        resp = self.client.get("/system-prompt", params={"chat_id": "abc"})
+        self.assertTrue(
+            resp.headers.get("content-type", "").startswith("text/plain"),
+            f"Expected text/plain, got {resp.headers.get('content-type')}",
+        )
+
+    def test_public_base_url_header_is_returned(self):
+        """The filter needs the public URL to build browser-facing preview/archive
+        links but its ORCHESTRATOR_URL Valve holds the internal URL. Server must
+        expose the public URL (from PUBLIC_BASE_URL env) on every /system-prompt
+        response so the filter can cache and use it in outlet()."""
+        resp = self.client.get("/system-prompt", params={"chat_id": "abc"})
+        self.assertEqual(resp.status_code, 200)
+        header = resp.headers.get("X-Public-Base-URL")
+        self.assertIsNotNone(header, "X-Public-Base-URL header missing")
+        self.assertEqual(header, self.public_base_url)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/orchestrator/test_tool_descriptions.py

@@ -0,0 +1,52 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""
+Tier 1 — MCP tool descriptions must mention README.md as the recovery hint.
+
+Static `instructions=` kwarg on the FastMCP constructor (Tier 3 fallback)
+must also mention README.md and resources/list — the entry
+points a confused client would otherwise miss.
+"""
+import asyncio
+import sys
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent.parent
+sys.path.insert(0, str(ROOT / "computer-use-server"))
+
+import mcp_tools  # noqa: E402
+
+
+class ToolDescriptionsContract(unittest.TestCase):
+    def test_bash_tool_description_mentions_readme(self):
+        tools = asyncio.run(mcp_tools.mcp.list_tools())
+        bash = next((t for t in tools if t.name == "bash_tool"), None)
+        self.assertIsNotNone(bash, "bash_tool tool missing from tools/list")
+        self.assertIn("README.md", bash.description)
+        self.assertIn("/home/assistant", bash.description)
+
+    def test_view_description_mentions_readme(self):
+        tools = asyncio.run(mcp_tools.mcp.list_tools())
+        view = next((t for t in tools if t.name == "view"), None)
+        self.assertIsNotNone(view, "view tool missing from tools/list")
+        self.assertIn("README.md", view.description)
+
+    def test_static_instructions_mentions_fallback_channels(self):
+        static = mcp_tools._STATIC_INSTRUCTIONS
+        # Two fallback pointers a confused client needs. We intentionally do
+        # NOT advertise prompts/get — naming a prompt "system" is off-spec
+        # (PromptMessage.role ∈ {user, assistant}) and InitializeResult.
+        # instructions is the canonical channel for server instructions.
+        self.assertIn("README.md", static)
+        self.assertIn("resources/list", static)
+        self.assertNotIn("prompts/get", static)
+
+    def test_total_tool_count_unchanged_at_five(self):
+        """We promised the user: 5 tools before, 5 tools after."""
+        tools = asyncio.run(mcp_tools.mcp.list_tools())
+        self.assertEqual(len(tools), 5, f"tool count drifted: {[t.name for t in tools]}")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/orchestrator/test_view_image.py

@@ -0,0 +1,201 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""Tests for view() image processing path — Pillow 12 API and return structure.
+
+Run: cd computer-use-server && python -m pytest ../tests/orchestrator/test_view_image.py -v
+"""
+
+import os
+import sys
+import unittest
+from unittest.mock import patch, MagicMock, AsyncMock
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'computer-use-server'))
+
+from context_vars import current_chat_id
+
+FAKE_B64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
+
+
+def _mock_container():
+    c = MagicMock()
+    c.id = "mock-container-id"
+    c.name = "owui-chat-test"
+    c.status = "running"
+    return c
+
+
+class TestViewImagePillow12Api(unittest.IsolatedAsyncioTestCase):
+    """Verify that view() generates Pillow 12-compatible Python code (Image.Resampling.LANCZOS)."""
+
+    def setUp(self):
+        current_chat_id.set("test-chat")
+
+    @patch("mcp_tools._ensure_gitlab_token", new_callable=AsyncMock)
+    @patch("mcp_tools._get_or_create_container", return_value=_mock_container())
+    @patch("mcp_tools._execute_bash")
+    async def test_command_uses_resampling_lanczos(self, mock_exec, mock_container, mock_token):
+        """The resize command sent to the container must use Image.Resampling.LANCZOS (Pillow 12 API)."""
+        from mcp_tools import view
+
+        captured = []
+
+        def capture(container, cmd):
+            captured.append(cmd)
+            return {"output": FAKE_B64, "exit_code": 0}
+
+        mock_exec.side_effect = capture
+        await view("check api", "/tmp/image.png")
+
+        self.assertTrue(captured, "Expected _execute_bash to be called for image file")
+        cmd = captured[0]
+        self.assertIn(
+            "Image.Resampling.LANCZOS",
+            cmd,
+            "Pillow 12 requires Image.Resampling.LANCZOS — old Image.LANCZOS was removed",
+        )
+
+    @patch("mcp_tools._ensure_gitlab_token", new_callable=AsyncMock)
+    @patch("mcp_tools._get_or_create_container", return_value=_mock_container())
+    @patch("mcp_tools._execute_bash")
+    async def test_command_does_not_use_deprecated_lanczos(self, mock_exec, mock_container, mock_token):
+        """The resize command must NOT use the deprecated bare Image.LANCZOS attribute."""
+        from mcp_tools import view
+
+        captured = []
+
+        def capture(container, cmd):
+            captured.append(cmd)
+            return {"output": FAKE_B64, "exit_code": 0}
+
+        mock_exec.side_effect = capture
+        await view("check api", "/tmp/photo.jpg")
+
+        self.assertTrue(captured)
+        cmd = captured[0]
+        # Image.LANCZOS without .Resampling is the deprecated Pillow 11 attribute
+        # It appears as ",Image.LANCZOS)" or " Image.LANCZOS)" — not as part of "Resampling.LANCZOS"
+        import re
+        deprecated = re.search(r'(?<!Resampling\.)Image\.LANCZOS', cmd)
+        self.assertIsNone(
+            deprecated,
+            f"Deprecated Image.LANCZOS found in command (use Image.Resampling.LANCZOS): {cmd!r}",
+        )
+
+
+class TestViewImageReturnsStructuredContent(unittest.IsolatedAsyncioTestCase):
+    """Verify the structured [text, image_url] return format for image files."""
+
+    def setUp(self):
+        current_chat_id.set("test-chat")
+
+    def _make_exec_mock(self, b64=FAKE_B64, exit_code=0):
+        return MagicMock(return_value={"output": b64, "exit_code": exit_code})
+
+    @patch("mcp_tools._ensure_gitlab_token", new_callable=AsyncMock)
+    @patch("mcp_tools._get_or_create_container", return_value=_mock_container())
+    @patch("mcp_tools._execute_bash")
+    async def test_png_returns_list_with_two_items(self, mock_exec, mock_container, mock_token):
+        from mcp_tools import view
+        mock_exec.side_effect = self._make_exec_mock()
+        result = await view("view image", "/tmp/test.png")
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 2)
+
+    @patch("mcp_tools._ensure_gitlab_token", new_callable=AsyncMock)
+    @patch("mcp_tools._get_or_create_container", return_value=_mock_container())
+    @patch("mcp_tools._execute_bash")
+    async def test_first_item_is_text_type(self, mock_exec, mock_container, mock_token):
+        from mcp_tools import view
+        mock_exec.side_effect = self._make_exec_mock()
+        result = await view("view image", "/tmp/test.png")
+        self.assertEqual(result[0]["type"], "text")
+
+    @patch("mcp_tools._ensure_gitlab_token", new_callable=AsyncMock)
+    @patch("mcp_tools._get_or_create_container", return_value=_mock_container())
+    @patch("mcp_tools._execute_bash")
+    async def test_second_item_is_image_url_type(self, mock_exec, mock_container, mock_token):
+        from mcp_tools import view
+        mock_exec.side_effect = self._make_exec_mock()
+        result = await view("view image", "/tmp/test.png")
+        self.assertEqual(result[1]["type"], "image_url")
+
+    @patch("mcp_tools._ensure_gitlab_token", new_callable=AsyncMock)
+    @patch("mcp_tools._get_or_create_container", return_value=_mock_container())
+    @patch("mcp_tools._execute_bash")
+    async def test_image_url_is_data_uri(self, mock_exec, mock_container, mock_token):
+        from mcp_tools import view
+        mock_exec.side_effect = self._make_exec_mock()
+        result = await view("view image", "/tmp/test.png")
+        url = result[1]["image_url"]["url"]
+        self.assertTrue(
+            url.startswith("data:image/jpeg;base64,"),
+            f"Expected data URI, got: {url[:60]}",
+        )
+
+    @patch("mcp_tools._ensure_gitlab_token", new_callable=AsyncMock)
+    @patch("mcp_tools._get_or_create_container", return_value=_mock_container())
+    @patch("mcp_tools._execute_bash")
+    async def test_data_uri_contains_b64_payload(self, mock_exec, mock_container, mock_token):
+        from mcp_tools import view
+        mock_exec.side_effect = self._make_exec_mock(b64=FAKE_B64)
+        result = await view("view image", "/tmp/test.png")
+        url = result[1]["image_url"]["url"]
+        self.assertIn(FAKE_B64, url)
+
+    @patch("mcp_tools._ensure_gitlab_token", new_callable=AsyncMock)
+    @patch("mcp_tools._get_or_create_container", return_value=_mock_container())
+    @patch("mcp_tools._execute_bash")
+    async def test_container_failure_returns_error_string(self, mock_exec, mock_container, mock_token):
+        """When the container command fails, view() must return a plain error string."""
+        from mcp_tools import view
+        mock_exec.side_effect = self._make_exec_mock(b64="Permission denied", exit_code=1)
+        result = await view("view image", "/tmp/secret.png")
+        self.assertIsInstance(result, str)
+        self.assertIn("Error", result)
+
+
+class TestViewImageExtensions(unittest.IsolatedAsyncioTestCase):
+    """All declared image extensions must trigger image processing path, not text path."""
+
+    def setUp(self):
+        current_chat_id.set("test-chat")
+
+    async def _check_ext(self, ext):
+        from mcp_tools import view
+
+        with patch("mcp_tools._ensure_gitlab_token", new_callable=AsyncMock), \
+             patch("mcp_tools._get_or_create_container", return_value=_mock_container()), \
+             patch("mcp_tools._execute_bash", return_value={"output": FAKE_B64, "exit_code": 0}):
+            result = await view("view image", f"/tmp/file{ext}")
+
+        self.assertIsInstance(
+            result, list,
+            f"Extension {ext!r} should return structured content list, got: {type(result).__name__}",
+        )
+
+    async def test_jpg_extension(self):
+        await self._check_ext(".jpg")
+
+    async def test_jpeg_extension(self):
+        await self._check_ext(".jpeg")
+
+    async def test_png_extension(self):
+        await self._check_ext(".png")
+
+    async def test_gif_extension(self):
+        await self._check_ext(".gif")
+
+    async def test_webp_extension(self):
+        await self._check_ext(".webp")
+
+    async def test_uppercase_png_extension(self):
+        """Extension matching must be case-insensitive."""
+        await self._check_ext(".PNG")
+
+    async def test_uppercase_jpg_extension(self):
+        await self._check_ext(".JPG")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/patches/conftest.py

@@ -0,0 +1,30 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""Shared pytest fixtures for backend patch tests.
+
+Provides byte-identical v0.9.1 upstream source as test fixtures for
+patch-apply / idempotency / fail-loud coverage.
+"""
+from pathlib import Path
+
+FIXTURES_DIR = Path(__file__).parent / "fixtures"
+MIDDLEWARE_V091 = FIXTURES_DIR / "middleware_v0.9.1.py"
+RETRIEVAL_V091 = FIXTURES_DIR / "retrieval_v0.9.1.py"
+MIDDLEWARE_V092 = FIXTURES_DIR / "middleware_v0.9.2.py"
+RETRIEVAL_V092 = FIXTURES_DIR / "retrieval_v0.9.2.py"
+
+
+def load_middleware_v091() -> str:
+    return MIDDLEWARE_V091.read_text(encoding="utf-8")
+
+
+def load_retrieval_v091() -> str:
+    return RETRIEVAL_V091.read_text(encoding="utf-8")
+
+
+def load_middleware_v092() -> str:
+    return MIDDLEWARE_V092.read_text(encoding="utf-8")
+
+
+def load_retrieval_v092() -> str:
+    return RETRIEVAL_V092.read_text(encoding="utf-8")

package/tests/patches/fixtures/__init__.py

@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""Fixture package for backend patch tests.
+
+Fixture files (middleware_v0.9.{1,2}.py, retrieval_v0.9.{1,2}.py) are
+byte-identical extracts from upstream Open WebUI v0.9.1 / v0.9.2 — DO NOT
+modify them. They are not imported as Python modules; they are read as
+text by the patch test harness. The v0.9.1 fixtures pin shim regression
+coverage; the build itself targets v0.9.2 strictly.
+"""