npm - @hybridlabor-api/aos - Versions diffs - 4.3.0 → 4.4.1 - Mend

@hybridlabor-api/aos 4.3.0 → 4.4.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1052) hide show

package/mcps/windows-computer-use-mcp/tests/test_portmanteau_windows_mock.py DELETED Viewed

@@ -1,173 +0,0 @@
-"""Mock-based tests for the portmanteau window management tools.
-These tests use mocks and don't require real windows to be open.
-"""
-from unittest.mock import MagicMock, patch
-class TestPortmanteauWindowsMock:
-    """Mock-based tests for the automation_windows portmanteau tool."""
-    @patch("windows_computer_use_mcp.tools.portmanteau_windows._get_desktop")
-    @patch("windows_computer_use_mcp.tools.portmanteau_windows.automation_windows")
-    def test_activate_window_success(self, mock_automation_windows, mock_get_desktop, app_instance):
-        """Test successful window activation with mocks."""
-        # Setup mocks
-        mock_window = MagicMock()
-        mock_window.is_minimized.return_value = False
-        mock_window.has_focus.return_value = True
-        mock_window.is_visible.return_value = True
-        mock_window.is_enabled.return_value = True
-        mock_desktop = MagicMock()
-        mock_desktop.window.return_value = mock_window
-        mock_get_desktop.return_value = mock_desktop
-        # Setup the mock to return our expected result
-        expected_result = {
-            "status": "success",
-            "operation": "activate",
-            "action": "activated",
-            "handle": 12345,
-            "has_focus": True,
-            "is_visible": True,
-            "is_enabled": True,
-            "timestamp": "2023-01-01T00:00:00",
-        }
-        mock_automation_windows.return_value = expected_result
-        # Import here to get the patched version
-        from windows_computer_use_mcp.tools.portmanteau_windows import automation_windows
-        # Call the function
-        result = automation_windows("activate", handle=12345)
-        # Verify the result
-        assert result == expected_result
-    @patch("windows_computer_use_mcp.tools.portmanteau_windows._get_desktop")
-    @patch("windows_computer_use_mcp.tools.portmanteau_windows.automation_windows")
-    def test_activate_minimized_window(self, mock_automation_windows, mock_get_desktop, app_instance):
-        """Test activating a minimized window with mocks."""
-        # Setup mocks
-        mock_window = MagicMock()
-        mock_window.is_minimized.return_value = True
-        mock_window.has_focus.return_value = True
-        mock_window.is_visible.return_value = True
-        mock_window.is_enabled.return_value = True
-        mock_desktop = MagicMock()
-        mock_desktop.window.return_value = mock_window
-        mock_get_desktop.return_value = mock_desktop
-        # Setup the mock to return our expected result
-        expected_result = {
-            "status": "success",
-            "operation": "activate",
-            "action": "activated",
-            "handle": 12345,
-            "has_focus": True,
-            "is_visible": True,
-            "is_enabled": True,
-            "timestamp": "2023-01-01T00:00:00",
-        }
-        mock_automation_windows.return_value = expected_result
-        # Import here to get the patched version
-        from windows_computer_use_mcp.tools.portmanteau_windows import automation_windows
-        # Call the function
-        result = automation_windows("activate", handle=12345)
-        # Verify the result
-        assert result == expected_result
-    @patch("windows_computer_use_mcp.tools.portmanteau_windows._get_desktop")
-    @patch("windows_computer_use_mcp.tools.portmanteau_windows.automation_windows")
-    def test_activate_window_failure(self, mock_automation_windows, mock_get_desktop, app_instance):
-        """Test window activation failure with mocks."""
-        # Setup the mock to return an error result
-        expected_result = {
-            "status": "error",
-            "operation": "activate",
-            "handle": 99999,
-            "error": "Error activating window: Window not found",
-            "error_type": "Exception",
-            "window_state": {
-                "exists": False,
-                "is_visible": False,
-                "is_enabled": False,
-                "has_focus": False,
-                "is_minimized": False,
-            },
-            "timestamp": "2023-01-01T00:00:00",
-        }
-        mock_automation_windows.return_value = expected_result
-        # Import here to get the patched version
-        from windows_computer_use_mcp.tools.portmanteau_windows import automation_windows
-        # Call the function
-        result = automation_windows("activate", handle=99999)
-        # Verify the error result
-        assert result == expected_result
-    @patch("windows_computer_use_mcp.tools.portmanteau_windows._get_desktop")
-    @patch("windows_computer_use_mcp.tools.portmanteau_windows.automation_windows")
-    def test_activate_nonexistent_window(self, mock_automation_windows, mock_get_desktop, app_instance):
-        """Test activating a non-existent window with mocks."""
-        # Setup the mock to return an error result for non-existent window
-        expected_result = {
-            "status": "error",
-            "operation": "activate",
-            "handle": 99999,
-            "error": "No window found with handle 99999",
-            "error_type": "RuntimeError",
-            "window_state": {
-                "exists": False,
-                "is_visible": False,
-                "is_enabled": False,
-                "has_focus": False,
-                "is_minimized": False,
-            },
-            "timestamp": "2023-01-01T00:00:00",
-        }
-        mock_automation_windows.return_value = expected_result
-        # Import here to get the patched version
-        from windows_computer_use_mcp.tools.portmanteau_windows import automation_windows
-        # Call the function
-        result = automation_windows("activate", handle=99999)
-        # Verify the error result
-        assert result == expected_result
-    @patch("windows_computer_use_mcp.tools.portmanteau_windows._get_desktop")
-    @patch("windows_computer_use_mcp.tools.portmanteau_windows.automation_windows")
-    def test_activate_window_verify_focus(self, mock_automation_windows, mock_get_desktop, app_instance):
-        """Test window activation with focus verification using mocks."""
-        # Setup the mock to return a success result but without focus
-        expected_result = {
-            "status": "success",
-            "operation": "activate",
-            "action": "activated",
-            "handle": 12345,
-            "has_focus": False,  # Simulate focus not gained
-            "is_visible": True,
-            "is_enabled": True,
-            "timestamp": "2023-01-01T00:00:00",
-        }
-        mock_automation_windows.return_value = expected_result
-        # Import here to get the patched version
-        from windows_computer_use_mcp.tools.portmanteau_windows import automation_windows
-        # Call the function
-        result = automation_windows("activate", handle=12345)
-        # Verify the result indicates a warning about focus
-        assert result["status"] == "success"  # Still success, but with warning
-        assert result["operation"] == "activate"
-        assert result["has_focus"] is False  # Indicates focus wasn't gained

package/mcps/windows-computer-use-mcp/tests/test_portmanteau_windows_real.py DELETED Viewed

@@ -1,139 +0,0 @@
-"""Real window tests for the portmanteau window management tools.
-These tests require real windows and will be skipped unless PYWINAUTO_TEST_REAL_WINDOWS=1 is set.
-"""
-import os
-import subprocess
-import sys
-import time
-import pytest
-# Check if we should run real window tests (set PYWINAUTO_TEST_REAL_WINDOWS=1 to enable)
-REAL_WINDOW_TESTS = os.environ.get("PYWINAUTO_TEST_REAL_WINDOWS", "").lower() in (
-    "1",
-    "true",
-    "yes",
-)
-SKIP_REAL_TESTS = not REAL_WINDOW_TESTS or not sys.platform.startswith("win")
-@pytest.mark.requires_hardware
-@pytest.mark.destructive
-class TestPortmanteauWindowsReal:
-    """Real window tests for the automation_windows portmanteau tool.
-    These tests will be skipped unless PYWINAUTO_TEST_REAL_WINDOWS=1 is set.
-    """
-    test_process = None
-    test_window_handle = None
-    test_window_started = False
-    @classmethod
-    def setup_class(cls):
-        """Start a test window for real testing if enabled."""
-        if not REAL_WINDOW_TESTS:
-            return
-        try:
-            # Start Notepad for real window testing
-            cls.test_process = subprocess.Popen(["notepad.exe"], creationflags=subprocess.CREATE_NEW_CONSOLE)
-            time.sleep(2)  # Give it time to start
-            # Get the window handle
-            from pywinauto import Desktop
-            desktop = Desktop(backend="uia")
-            window = desktop.window(title="Untitled - Notepad")
-            if window.exists():
-                cls.test_window_handle = window.handle
-                cls.test_window_started = True
-                print(f"Test window started with handle: {cls.test_window_handle}")
-            else:
-                print("Warning: Failed to find test window")
-        except Exception as e:
-            print(f"Warning: Failed to start test window: {e}")
-            cls.test_process = None
-    @classmethod
-    def teardown_class(cls):
-        """Clean up test windows."""
-        if cls.test_process:
-            try:
-                cls.test_process.terminate()
-                try:
-                    cls.test_process.wait(timeout=5)
-                except subprocess.TimeoutExpired:
-                    cls.test_process.kill()
-            except Exception as e:
-                print(f"Error cleaning up test process: {e}")
-            cls.test_process = None
-            cls.test_window_handle = None
-            cls.test_window_started = False
-    def _get_test_window_handle(self):
-        """Get the test window handle if available."""
-        if not self.test_window_started or not self.test_window_handle:
-            pytest.skip("No real window available for testing")
-        from pywinauto import Desktop
-        try:
-            desktop = Desktop(backend="uia")
-            window = desktop.window(handle=self.test_window_handle)
-            if window.exists():
-                return self.test_window_handle
-        except Exception as e:
-            print(f"Error verifying window: {e}")
-        pytest.skip("Test window no longer available")
-    @pytest.mark.skipif(SKIP_REAL_TESTS, reason="Real window tests not enabled or not on Windows")
-    def test_real_window_activation(self):
-        """Test activating a real Notepad window."""
-        from windows_computer_use_mcp.tools.portmanteau_windows import automation_windows
-        handle = self._get_test_window_handle()
-        # Test activation
-        result = automation_windows("activate", handle=handle)
-        assert result["status"] == "success", f"Activation failed: {result.get('error', 'Unknown error')}"
-        assert result["has_focus"] is True, "Window should have focus after activation"
-        # Verify the window is actually active
-        from pywinauto import Desktop
-        desktop = Desktop(backend="uia")
-        active_window = desktop.window(handle=handle)
-        assert active_window.is_active(), "Window should be active after activation"
-    @pytest.mark.skipif(SKIP_REAL_TESTS, reason="Real window tests not enabled or not on Windows")
-    def test_real_minimized_window_activation(self):
-        """Test restoring and activating a minimized window."""
-        from pywinauto import Desktop
-        from windows_computer_use_mcp.tools.portmanteau_windows import automation_windows
-        handle = self._get_test_window_handle()
-        desktop = Desktop(backend="uia")
-        window = desktop.window(handle=handle)
-        try:
-            # Minimize the window first
-            window.minimize()
-            time.sleep(1)  # Give it time to minimize
-            # Test activation
-            result = automation_windows("activate", handle=handle)
-            # Verify results
-            assert result["status"] == "success"
-            assert result["has_focus"] is True
-            assert window.is_visible() is True
-            assert window.is_minimized() is False
-        finally:
-            # Ensure window is restored for other tests
-            window.restore()

package/mcps/windows-computer-use-mcp/tests/test_retry.py DELETED Viewed

@@ -1,26 +0,0 @@
-"""Tests for retry helper."""
-import pytest
-from windows_computer_use_mcp.retry import with_retry
-def test_with_retry_succeeds_second_attempt():
-    calls = {"n": 0}
-    def flaky():
-        calls["n"] += 1
-        if calls["n"] < 2:
-            raise RuntimeError("nope")
-        return "ok"
-    assert with_retry(flaky, attempts=3, delay=0.01, label="test") == "ok"
-    assert calls["n"] == 2
-def test_with_retry_raises_after_exhausted():
-    def always_fail():
-        raise ValueError("fail")
-    with pytest.raises(ValueError):
-        with_retry(always_fail, attempts=2, delay=0.01, label="test")

package/mcps/windows-computer-use-mcp/tests/test_safety_api.py DELETED Viewed

@@ -1,24 +0,0 @@
-"""REST safety snapshot — no hardware."""
-from __future__ import annotations
-import pytest
-from fastapi.testclient import TestClient
-from windows_computer_use_mcp.server import app
-@pytest.fixture
-def client() -> TestClient:
-    return TestClient(app)
-def test_safety_status_returns_snapshot(client: TestClient) -> None:
-    r = client.get("/api/v1/safety/status")
-    assert r.status_code == 200
-    data = r.json()
-    assert data.get("status") == "success"
-    assert "snapshot" in data
-    assert "face_tool_opt_in" in data
-    assert "env" in data
-    assert "hitl" in data

package/mcps/windows-computer-use-mcp/tests/test_template_library.py DELETED Viewed

@@ -1,53 +0,0 @@
-"""Tests for per-app template library (T2.3)."""
-from pathlib import Path
-from windows_computer_use_mcp import template_library
-def test_manifest_lists_vroid_templates():
-    entries = template_library.list_template_entries("vroidstudio")
-    ids = {e.template_id for e in entries}
-    assert "export_dialog_title" in ids
-    assert "sample_tile_female" in ids
-def test_ensure_placeholder_templates(tmp_path: Path, monkeypatch):
-    root = tmp_path / "templates"
-    monkeypatch.setattr(template_library, "_TEMPLATES_ROOT", root)
-    manifest = root / "vroidstudio" / "manifest.yaml"
-    manifest.parent.mkdir(parents=True)
-    manifest.write_text(
-        """
-app: vroidstudio
-version: default
-templates:
-  - id: test_tile
-    file: test_tile.png
-    description: test
-""",
-        encoding="utf-8",
-    )
-    created = template_library.ensure_placeholder_templates("vroidstudio")
-    assert len(created) == 1
-    assert Path(created[0]).is_file()
-def test_resolve_template_after_placeholder(monkeypatch, tmp_path: Path):
-    root = tmp_path / "templates"
-    monkeypatch.setattr(template_library, "_TEMPLATES_ROOT", root)
-    manifest = root / "vroidstudio" / "manifest.yaml"
-    manifest.parent.mkdir(parents=True)
-    manifest.write_text(
-        """
-app: vroidstudio
-version: default
-templates:
-  - id: ok_btn
-    file: ok_btn.png
-""",
-        encoding="utf-8",
-    )
-    template_library.ensure_placeholder_templates("vroidstudio")
-    path = template_library.resolve_template("vroidstudio", "ok_btn")
-    assert path.is_file()

package/mcps/windows-computer-use-mcp/tests/test_utils.py DELETED Viewed

@@ -1,185 +0,0 @@
-"""Tests for utility functions and decorators."""
-import time
-from unittest.mock import MagicMock, patch
-import pytest
-from windows_computer_use_mcp.tools import utils
-class TestErrorResponse:
-    """Tests for ErrorResponse model."""
-    def test_error_response_creation(self):
-        """Test creating an ErrorResponse."""
-        error = utils.ErrorResponse(error="Test error", error_type="ValueError")
-        assert error.success is False
-        assert error.error == "Test error"
-        assert error.error_type == "ValueError"
-        assert isinstance(error.timestamp, str)
-class TestSuccessResponse:
-    """Tests for SuccessResponse model."""
-    def test_success_response_creation(self):
-        """Test creating a SuccessResponse."""
-        success = utils.SuccessResponse(data={"result": "test"})
-        assert success.success is True
-        assert success.data == {"result": "test"}
-        assert isinstance(success.timestamp, str)
-class TestHandleErrors:
-    """Tests for handle_errors decorator."""
-    def test_handle_errors_success(self):
-        """Test error handler with successful function."""
-        @utils.handle_errors
-        def test_func():
-            return {"result": "success"}
-        result = test_func()
-        assert result["success"] is True
-        assert "data" in result
-        assert "timestamp" in result
-    def test_handle_errors_exception(self):
-        """Test error handler with exception."""
-        @utils.handle_errors
-        def test_func():
-            raise ValueError("Test error")
-        result = test_func()
-        assert result["success"] is False
-        assert result["error"] == "Test error"
-        assert result["error_type"] == "ValueError"
-        assert "timestamp" in result
-    def test_handle_errors_exception_no_args(self):
-        """Test error handler with exception but no args in extra."""
-        @utils.handle_errors
-        def test_func_no_args():
-            raise ValueError("Test error")
-        result = test_func_no_args()
-        assert result["success"] is False
-        assert result["error"] == "Test error"
-    def test_handle_errors_already_has_response(self):
-        """Test error handler when function already returns response dict."""
-        @utils.handle_errors
-        def test_func():
-            return {"success": True, "data": "test"}
-        result = test_func()
-        assert result["success"] is True
-        assert result["data"] == "test"
-class TestLogExecution:
-    """Tests for log_execution decorator."""
-    @patch("windows_computer_use_mcp.tools.utils.logger")
-    def test_log_execution_success(self, mock_logger):
-        """Test execution logging with successful function."""
-        @utils.log_execution
-        def test_func():
-            return "result"
-        result = test_func()
-        assert result == "result"
-        assert mock_logger.info.called
-    @patch("windows_computer_use_mcp.tools.utils.logger")
-    def test_log_execution_exception(self, mock_logger):
-        """Test execution logging with exception."""
-        @utils.log_execution
-        def test_func():
-            raise ValueError("Test error")
-        with pytest.raises(ValueError):
-            test_func()
-        assert mock_logger.error.called
-class TestTimer:
-    """Tests for timer context manager."""
-    @patch("windows_computer_use_mcp.tools.utils.logger")
-    def test_timer_context_manager(self, mock_logger):
-        """Test timer context manager."""
-        with utils.timer("test operation"):
-            time.sleep(0.01)
-        assert mock_logger.debug.called
-class TestValidateWindowHandle:
-    """Tests for validate_window_handle function."""
-    @patch("windows_computer_use_mcp.tools.utils.Desktop")
-    def test_validate_window_handle_valid(self, mock_desktop):
-        """Test validating a valid window handle."""
-        mock_desktop_obj = MagicMock()
-        mock_window = MagicMock()
-        mock_window.exists.return_value = True
-        mock_desktop_obj.window.return_value = mock_window
-        mock_desktop.return_value = mock_desktop_obj
-        result = utils.validate_window_handle(12345)
-        assert result is True
-    @patch("windows_computer_use_mcp.tools.utils.Desktop")
-    def test_validate_window_handle_invalid(self, mock_desktop):
-        """Test validating an invalid window handle."""
-        mock_desktop_obj = MagicMock()
-        mock_desktop_obj.window.side_effect = Exception("Window not found")
-        mock_desktop.return_value = mock_desktop_obj
-        result = utils.validate_window_handle(99999)
-        assert result is False
-class TestGetDesktop:
-    """Tests for get_desktop function."""
-    @patch("windows_computer_use_mcp.tools.utils.Desktop")
-    def test_get_desktop_success(self, mock_desktop):
-        """Test getting desktop instance successfully."""
-        mock_desktop_obj = MagicMock()
-        mock_desktop.return_value = mock_desktop_obj
-        result = utils.get_desktop()
-        assert result == mock_desktop_obj
-        mock_desktop.assert_called_once_with(backend="uia")
-    @patch("windows_computer_use_mcp.tools.utils.Desktop")
-    @patch("windows_computer_use_mcp.tools.utils.logger")
-    def test_get_desktop_failure(self, mock_logger, mock_desktop):
-        """Test getting desktop instance with failure."""
-        mock_desktop.side_effect = Exception("Desktop init failed")
-        with pytest.raises(RuntimeError) as exc_info:
-            utils.get_desktop()
-        assert "Failed to initialize Windows Desktop automation" in str(exc_info.value)
-        assert mock_logger.error.called

package/mcps/windows-computer-use-mcp/web_sota/src-tauri/icons/icon.png DELETED Viewed

Binary file