mcpmon 0.1.4 → 0.3.0

package/tests/test_mcpmon.py

@@ -0,0 +1,493 @@
+"""Unit and integration tests for mcpmon."""
+
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from mcpmon import (
+    Logger,
+    LogLevel,
+    get_change_type_name,
+    should_reload,
+)
+
+
+# =============================================================================
+# Unit Tests - Logger
+# =============================================================================
+
+
+class TestLogLevel:
+    """Test LogLevel enum."""
+
+    def test_level_ordering(self):
+        """Log levels should be ordered: QUIET < NORMAL < VERBOSE < DEBUG."""
+        assert LogLevel.QUIET < LogLevel.NORMAL
+        assert LogLevel.NORMAL < LogLevel.VERBOSE
+        assert LogLevel.VERBOSE < LogLevel.DEBUG
+
+    def test_level_values(self):
+        """Log levels should have expected numeric values."""
+        assert LogLevel.QUIET == 0
+        assert LogLevel.NORMAL == 1
+        assert LogLevel.VERBOSE == 2
+        assert LogLevel.DEBUG == 3
+
+
+class TestLogger:
+    """Test Logger class."""
+
+    def test_default_settings(self):
+        """Logger should have sensible defaults."""
+        logger = Logger()
+        assert logger.level == LogLevel.NORMAL
+        assert logger.show_timestamps is False
+        assert logger.log_file is None
+
+    def test_format_basic(self):
+        """Format should include [mcpmon] prefix."""
+        logger = Logger()
+        msg = logger._format("test message")
+        assert msg.startswith("[mcpmon]")
+        assert "test message" in msg
+
+    def test_format_with_pid(self):
+        """Format should include PID when provided."""
+        logger = Logger()
+        msg = logger._format("test", pid=12345)
+        assert "pid:12345" in msg
+
+    def test_format_with_timestamps(self):
+        """Format should include timestamp when enabled."""
+        logger = Logger(show_timestamps=True)
+        msg = logger._format("test")
+        # Timestamp format is HH:MM:SS
+        import re
+        assert re.search(r"\d{2}:\d{2}:\d{2}", msg)
+
+    def test_format_without_timestamps(self):
+        """Format should not include timestamp when disabled."""
+        logger = Logger(show_timestamps=False)
+        msg = logger._format("test")
+        import re
+        # Should not have time pattern in basic format
+        assert not re.search(r"\d{2}:\d{2}:\d{2}", msg)
+
+    def test_info_respects_level(self, capsys):
+        """info() should respect log level."""
+        logger = Logger(level=LogLevel.QUIET)
+        logger.info("should not appear")
+        captured = capsys.readouterr()
+        assert "should not appear" not in captured.err
+
+        logger = Logger(level=LogLevel.NORMAL)
+        logger.info("should appear")
+        captured = capsys.readouterr()
+        assert "should appear" in captured.err
+
+    def test_verbose_respects_level(self, capsys):
+        """verbose() should respect log level."""
+        logger = Logger(level=LogLevel.NORMAL)
+        logger.verbose("should not appear")
+        captured = capsys.readouterr()
+        assert "should not appear" not in captured.err
+
+        logger = Logger(level=LogLevel.VERBOSE)
+        logger.verbose("should appear")
+        captured = capsys.readouterr()
+        assert "should appear" in captured.err
+
+    def test_debug_respects_level(self, capsys):
+        """debug() should respect log level."""
+        logger = Logger(level=LogLevel.VERBOSE)
+        logger.debug("should not appear")
+        captured = capsys.readouterr()
+        assert "should not appear" not in captured.err
+
+        logger = Logger(level=LogLevel.DEBUG)
+        logger.debug("should appear")
+        captured = capsys.readouterr()
+        assert "DEBUG:" in captured.err
+        assert "should appear" in captured.err
+
+    def test_error_always_shown(self, capsys):
+        """error() should always be shown, even at QUIET level."""
+        logger = Logger(level=LogLevel.QUIET)
+        logger.error("error message")
+        captured = capsys.readouterr()
+        assert "ERROR:" in captured.err
+        assert "error message" in captured.err
+
+    def test_log_file_write(self):
+        """Logger should write to file when configured."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".log", delete=False) as f:
+            log_path = Path(f.name)
+
+        try:
+            logger = Logger(log_file=log_path)
+            logger.open_file()
+            logger.info("file test message")
+            logger.close_file()
+
+            content = log_path.read_text()
+            assert "file test message" in content
+            # File logs should always have timestamps
+            import re
+            assert re.search(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}", content)
+        finally:
+            log_path.unlink(missing_ok=True)
+
+
+# =============================================================================
+# Unit Tests - File Watching
+# =============================================================================
+
+
+class TestShouldReload:
+    """Test should_reload function."""
+
+    def test_matching_extension(self):
+        """Should return True for matching extensions."""
+        from watchfiles import Change
+
+        changes = {(Change.modified, "/path/to/file.py")}
+        extensions = {"py"}
+
+        reload, matches = should_reload(changes, extensions)
+        assert reload is True
+        assert len(matches) == 1
+        assert matches[0][0] == "modified"
+        assert matches[0][1] == "/path/to/file.py"
+
+    def test_non_matching_extension(self):
+        """Should return False for non-matching extensions."""
+        from watchfiles import Change
+
+        changes = {(Change.modified, "/path/to/file.txt")}
+        extensions = {"py"}
+
+        reload, matches = should_reload(changes, extensions)
+        assert reload is False
+        assert len(matches) == 0
+
+    def test_multiple_extensions(self):
+        """Should match multiple configured extensions."""
+        from watchfiles import Change
+
+        extensions = {"py", "json", "yaml"}
+
+        for ext in ["py", "json", "yaml"]:
+            changes = {(Change.modified, f"/path/to/file.{ext}")}
+            reload, _ = should_reload(changes, extensions)
+            assert reload is True
+
+    def test_deleted_files_ignored(self):
+        """Should not reload for deleted files."""
+        from watchfiles import Change
+
+        changes = {(Change.deleted, "/path/to/file.py")}
+        extensions = {"py"}
+
+        reload, matches = should_reload(changes, extensions)
+        assert reload is False
+
+    def test_added_files_trigger_reload(self):
+        """Should reload for newly added files."""
+        from watchfiles import Change
+
+        changes = {(Change.added, "/path/to/new_file.py")}
+        extensions = {"py"}
+
+        reload, matches = should_reload(changes, extensions)
+        assert reload is True
+        assert matches[0][0] == "added"
+
+    def test_multiple_changes(self):
+        """Should handle multiple file changes."""
+        from watchfiles import Change
+
+        changes = {
+            (Change.modified, "/path/to/file1.py"),
+            (Change.modified, "/path/to/file2.py"),
+            (Change.modified, "/path/to/file3.txt"),  # Should not match
+        }
+        extensions = {"py"}
+
+        reload, matches = should_reload(changes, extensions)
+        assert reload is True
+        assert len(matches) == 2
+
+
+class TestGetChangeTypeName:
+    """Test get_change_type_name function."""
+
+    def test_change_types(self):
+        """Should return human-readable change type names."""
+        from watchfiles import Change
+
+        assert get_change_type_name(Change.added) == "added"
+        assert get_change_type_name(Change.modified) == "modified"
+        assert get_change_type_name(Change.deleted) == "deleted"
+
+
+# =============================================================================
+# Integration Tests
+# =============================================================================
+
+
+class TestIntegration:
+    """Integration tests for mcpmon."""
+
+    @pytest.fixture
+    def temp_dir(self):
+        """Create a temporary directory for testing."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            yield Path(tmpdir)
+
+    @pytest.fixture
+    def dummy_server(self, temp_dir):
+        """Create a dummy server script that logs when started."""
+        server_script = temp_dir / "server.py"
+        server_script.write_text("""
+import sys
+import time
+import signal
+
+print(f"[test-server] Started (pid={__import__('os').getpid()})", file=sys.stderr)
+sys.stderr.flush()
+
+def handle_term(sig, frame):
+    print("[test-server] Received SIGTERM", file=sys.stderr)
+    sys.exit(0)
+
+signal.signal(signal.SIGTERM, handle_term)
+
+while True:
+    time.sleep(0.1)
+""")
+        return server_script
+
+    def test_mcpmon_starts_server(self, temp_dir, dummy_server):
+        """mcpmon should start the server subprocess."""
+        proc = subprocess.Popen(
+            [
+                sys.executable,
+                "-m", "mcpmon",
+                "--watch", str(temp_dir),
+                "--", sys.executable, str(dummy_server),
+            ],
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            cwd=Path(__file__).parent.parent,
+        )
+
+        try:
+            # Wait for startup
+            time.sleep(2)
+
+            # Check that mcpmon is running
+            assert proc.poll() is None, "mcpmon should still be running"
+
+        finally:
+            proc.terminate()
+            proc.wait(timeout=5)
+
+    def test_mcpmon_restarts_on_change(self, temp_dir, dummy_server):
+        """mcpmon should restart server when watched file changes."""
+        # Create a watched file
+        watched_file = temp_dir / "watched.py"
+        watched_file.write_text("# initial")
+
+        log_file = temp_dir / "mcpmon.log"
+
+        proc = subprocess.Popen(
+            [
+                sys.executable,
+                "-m", "mcpmon",
+                "--watch", str(temp_dir),
+                "--ext", "py",
+                "--log-file", str(log_file),
+                "--", sys.executable, str(dummy_server),
+            ],
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            cwd=Path(__file__).parent.parent,
+        )
+
+        try:
+            # Wait for initial startup
+            time.sleep(2)
+
+            # Trigger a reload by modifying the watched file
+            watched_file.write_text("# modified")
+
+            # Wait for restart
+            time.sleep(2)
+
+            # Check log file for restart message
+            log_content = log_file.read_text()
+            assert "Restart #1" in log_content, f"Expected restart in log: {log_content}"
+
+        finally:
+            proc.terminate()
+            proc.wait(timeout=5)
+
+    def test_mcpmon_ignores_non_matching_files(self, temp_dir, dummy_server):
+        """mcpmon should ignore changes to non-matching extensions."""
+        # Create a non-matching file
+        other_file = temp_dir / "readme.txt"
+        other_file.write_text("initial")
+
+        log_file = temp_dir / "mcpmon.log"
+
+        proc = subprocess.Popen(
+            [
+                sys.executable,
+                "-m", "mcpmon",
+                "--watch", str(temp_dir),
+                "--ext", "py",  # Only watch .py files
+                "--debug",
+                "--log-file", str(log_file),
+                "--", sys.executable, str(dummy_server),
+            ],
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            cwd=Path(__file__).parent.parent,
+        )
+
+        try:
+            # Wait for initial startup
+            time.sleep(2)
+
+            # Modify the non-matching file
+            other_file.write_text("modified")
+
+            # Wait a bit
+            time.sleep(2)
+
+            # Check that no restart occurred
+            log_content = log_file.read_text()
+            assert "Restart #1" not in log_content, "Should not restart for .txt file"
+            # But should log that it was ignored (debug mode)
+            assert "Ignored" in log_content or "readme.txt" in log_content
+
+        finally:
+            proc.terminate()
+            proc.wait(timeout=5)
+
+    def test_mcpmon_graceful_shutdown(self, temp_dir, dummy_server):
+        """mcpmon should handle SIGTERM gracefully."""
+        log_file = temp_dir / "mcpmon.log"
+
+        proc = subprocess.Popen(
+            [
+                sys.executable,
+                "-m", "mcpmon",
+                "--watch", str(temp_dir),
+                "--log-file", str(log_file),
+                "--", sys.executable, str(dummy_server),
+            ],
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            cwd=Path(__file__).parent.parent,
+        )
+
+        try:
+            # Wait for startup
+            time.sleep(2)
+
+            # Send SIGTERM
+            proc.terminate()
+
+            # Wait for graceful shutdown
+            proc.wait(timeout=5)
+
+            # Check log for shutdown message
+            log_content = log_file.read_text()
+            assert "Shutdown complete" in log_content
+
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            pytest.fail("mcpmon did not shut down gracefully")
+
+    def test_mcpmon_timestamps_option(self, temp_dir, dummy_server):
+        """--timestamps should add timestamps to output."""
+        log_file = temp_dir / "mcpmon.log"
+
+        proc = subprocess.Popen(
+            [
+                sys.executable,
+                "-m", "mcpmon",
+                "--watch", str(temp_dir),
+                "--timestamps",
+                "--log-file", str(log_file),
+                "--", sys.executable, str(dummy_server),
+            ],
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            cwd=Path(__file__).parent.parent,
+        )
+
+        try:
+            time.sleep(2)
+        finally:
+            proc.terminate()
+            proc.wait(timeout=5)
+
+        # Log file always has full timestamps
+        import re
+        log_content = log_file.read_text()
+        assert re.search(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}", log_content)
+
+
+# =============================================================================
+# CLI Argument Tests
+# =============================================================================
+
+
+class TestCLI:
+    """Test CLI argument parsing."""
+
+    def test_help_flag(self):
+        """--help should show usage and exit 0."""
+        result = subprocess.run(
+            [sys.executable, "-m", "mcpmon", "--help"],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent,
+        )
+        assert result.returncode == 0
+        assert "Usage:" in result.stdout or "usage:" in result.stdout
+
+    def test_missing_command_error(self):
+        """Should error if no command specified."""
+        result = subprocess.run(
+            [sys.executable, "-m", "mcpmon", "--watch", "."],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent,
+        )
+        assert result.returncode != 0
+        assert "command" in result.stderr.lower() or "No command" in result.stderr
+
+    def test_version_in_help(self):
+        """Help should include examples."""
+        result = subprocess.run(
+            [sys.executable, "-m", "mcpmon", "--help"],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent,
+        )
+        assert "Examples:" in result.stdout

package/.github/.tmp/.generated-actions/run-pypi-publish-in-docker-container/action.yml

@@ -1 +0,0 @@
-{"name": "🏃", "description": "Run Docker container to upload Python distribution packages to PyPI", "inputs": {"user": {"description": "PyPI user", "required": false}, "password": {"description": "Password for your PyPI user or an access token", "required": false}, "repository-url": {"description": "The repository URL to use", "required": false}, "packages-dir": {"description": "The target directory for distribution", "required": false}, "verify-metadata": {"description": "Check metadata before uploading", "required": false}, "skip-existing": {"description": "Do not fail if a Python package distribution exists in the target package index", "required": false}, "verbose": {"description": "Show verbose output.", "required": false}, "print-hash": {"description": "Show hash values of files to be uploaded", "required": false}, "attestations": {"description": "[EXPERIMENTAL] Enable experimental support for PEP 740 attestations. Only works with PyPI and TestPyPI via Trusted Publishing.", "required": false}}, "runs": {"using": "docker", "image": "docker://ghcr.io/pypa/gh-action-pypi-publish:release-v1"}}

package/dist/mcpmon-0.1.4-py3-none-any.whl.publish.attestation

@@ -1 +0,0 @@
-{"version":1,"verification_material":{"certificate":"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","transparency_entries":[{"logIndex":"854724717","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"dsse","version":"0.0.1"},"integratedTime":"1769383533","inclusionPromise":{"signedEntryTimestamp":"MEQCIB4BSUl8FcjWriaoAZjRJcZ4Q4mtBJvXFdJJY5CGG4vCAiALbVdmSh0jVhxqATm9v29EnF0RCGS7D1dmMLPUHyvf9Q=="},"inclusionProof":{"logIndex":"732820455","rootHash":"eE1ekh3Xgk1rETOEFfJQR6ealKWkswYFPwZffvD5HLQ=","treeSize":"732820460","hashes":["pdGeTdNp4KglQuIDJuS3kpxwHtz8O2HLBWpvv1XO7LE=","/35+EsqjYiVWORgZJrJ8YmNvqD3zAGMwN16X+V0H4hw=","5Lpzt0SDkMvXkzuXQkM4IczaD3YieQihqNFRiJ/0j4I=","b5uNlze6Z88KmJxo+FmTFgLDzgycYBj0oyfE6wA63eY=","74KmBe4Kjlo2YGKnnWSZDq70uawwQKc6lVoDBeIyJZ0=","MZE7wMO38x+IyNk2UeqawjOiRE8nzWZDKxJ4B96w+ro=","8QqJNOeX+oNUh9Jl2kca4qTMqiJPStt58YXQM9mqAHw=","DwKwRQf8bLfvAlZCumHHqyln+KUP87MajXC3gQiRsXk=","rF9MeFdsXSqGF8vqzgxBkGyzLstktTr84yuHfN9eI14=","avGfYpplrUBIQg4ezCF3xrJGXOH8Uh/sOtaaNxjyqmo=","sss5FthkuTnwa241eO0hxXXBCR3QeypHRP73o9RzO9g=","jfukQMAVfCqCrlYwRqqUd/hbEP4yotGKGxR4+c54pfA=","OllZ6+8Si5cuPekJ1g/CP+sXnQHy2JgxYEUmTqicIqc=","dBkbakOCkLCPfwfbc9RJj5FE13JWP1L+K/QnvWbBXjw=","8UxdDATbCIzp+y4X0U33q0Ofz5gDN3girMGDR3eDQes=","i0MObzT1TBsOoj2fSfX5tVy/0RDAzekFRhxMA9dNLRk=","tpLJI2Sg9ZYY8iWiNmofGyoEHdnSBSJwiMmlIBYhOfQ=","O8/imYCTZtbxIc+69c8pb8IaxPdmSK7UPXh/ip+hoLI=","6OLWbtKvxLyT2cr4F2qdHh0quyYiSl/P7LpDfVrK6R8=","WFmkMhmL2tOzDi6lp4zGgaCzwux2vGOM44v1vr1wuDs=","F9MSQ5SmoFr+hoADclpdFY52/TLfHDnNPYb9ZNYO5gI=","T4DqWD42hAtN+vX8jKCWqoC4meE4JekI9LxYGCcPy1M="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n732820460\neE1ekh3Xgk1rETOEFfJQR6ealKWkswYFPwZffvD5HLQ=\n\n— rekor.sigstore.dev wNI9ajBGAiEAu2Y7qOW6TowsdnlINmGgzDLDuJ3Aef6HUi8Z+Oia+rACIQDpLVUacCCAMP3/rV66VfEaIJptyZcu7YttNHVsT2kKqw==\n"}},"canonicalizedBody":"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"}]},"envelope":{"statement":"eyJfdHlwZSI6Imh0dHBzOi8vaW4tdG90by5pby9TdGF0ZW1lbnQvdjEiLCJzdWJqZWN0IjpbeyJuYW1lIjoibWNwbW9uLTAuMS40LXB5My1ub25lLWFueS53aGwiLCJkaWdlc3QiOnsic2hhMjU2IjoiZWU0YjRmODlkMmU3MzI0MGMzODM3ZGJlYTM3ODhkNTEyMDA2ZDRlNmRmZDUyMmYzNWRiMzhmNDM0MWRmMmQxOCJ9fV0sInByZWRpY2F0ZVR5cGUiOiJodHRwczovL2RvY3MucHlwaS5vcmcvYXR0ZXN0YXRpb25zL3B1Ymxpc2gvdjEiLCJwcmVkaWNhdGUiOm51bGx9","signature":"MEUCIQDQFzNp2BXavnEjY95H6o7YRuVRJ+Qo4axkrrkypkRIZwIgTVCz4/E/7/DWK2HAw9z+pDNo73nVlr5lZa76WbzLOTM="}}

package/dist/mcpmon-0.1.4.tar.gz.publish.attestation

@@ -1 +0,0 @@
-{"version":1,"verification_material":{"certificate":"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","transparency_entries":[{"logIndex":"854724714","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"dsse","version":"0.0.1"},"integratedTime":"1769383532","inclusionPromise":{"signedEntryTimestamp":"MEUCIQDZSFWe7ove2wZmYjD9+E4wMIg1pKZyCabS093sxTb1jwIgGQ3wocq5ScAy8WF0PqWS3pBdFSLugsYGKJYR1w71LXk="},"inclusionProof":{"logIndex":"732820452","rootHash":"QqQZjFx9z+R7lB0+3aYwqKyeWxqEpwfolt93Cprx7nQ=","treeSize":"732820453","hashes":["5Lpzt0SDkMvXkzuXQkM4IczaD3YieQihqNFRiJ/0j4I=","74KmBe4Kjlo2YGKnnWSZDq70uawwQKc6lVoDBeIyJZ0=","MZE7wMO38x+IyNk2UeqawjOiRE8nzWZDKxJ4B96w+ro=","8QqJNOeX+oNUh9Jl2kca4qTMqiJPStt58YXQM9mqAHw=","DwKwRQf8bLfvAlZCumHHqyln+KUP87MajXC3gQiRsXk=","rF9MeFdsXSqGF8vqzgxBkGyzLstktTr84yuHfN9eI14=","avGfYpplrUBIQg4ezCF3xrJGXOH8Uh/sOtaaNxjyqmo=","sss5FthkuTnwa241eO0hxXXBCR3QeypHRP73o9RzO9g=","jfukQMAVfCqCrlYwRqqUd/hbEP4yotGKGxR4+c54pfA=","OllZ6+8Si5cuPekJ1g/CP+sXnQHy2JgxYEUmTqicIqc=","dBkbakOCkLCPfwfbc9RJj5FE13JWP1L+K/QnvWbBXjw=","8UxdDATbCIzp+y4X0U33q0Ofz5gDN3girMGDR3eDQes=","i0MObzT1TBsOoj2fSfX5tVy/0RDAzekFRhxMA9dNLRk=","tpLJI2Sg9ZYY8iWiNmofGyoEHdnSBSJwiMmlIBYhOfQ=","O8/imYCTZtbxIc+69c8pb8IaxPdmSK7UPXh/ip+hoLI=","6OLWbtKvxLyT2cr4F2qdHh0quyYiSl/P7LpDfVrK6R8=","WFmkMhmL2tOzDi6lp4zGgaCzwux2vGOM44v1vr1wuDs=","F9MSQ5SmoFr+hoADclpdFY52/TLfHDnNPYb9ZNYO5gI=","T4DqWD42hAtN+vX8jKCWqoC4meE4JekI9LxYGCcPy1M="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n732820453\nQqQZjFx9z+R7lB0+3aYwqKyeWxqEpwfolt93Cprx7nQ=\n\n— rekor.sigstore.dev wNI9ajBFAiBVLMSIaR0zcE5L0lp4GkSwIvzI7yF4azFq0BNIcw5X+gIhAIZlXAewEihLxBFfMpD0RMeEhPPG+1g6B+JIvyWoEXP7\n"}},"canonicalizedBody":"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"}]},"envelope":{"statement":"eyJfdHlwZSI6Imh0dHBzOi8vaW4tdG90by5pby9TdGF0ZW1lbnQvdjEiLCJzdWJqZWN0IjpbeyJuYW1lIjoibWNwbW9uLTAuMS40LnRhci5neiIsImRpZ2VzdCI6eyJzaGEyNTYiOiI5NWU3ZDQ3NmIwZTA5M2VmNTBlOTg5ZDY5YzU2YzM2NDdiZThlZjZiNTU2YTZhOTg4YjI5ZWY0NjgxMTFkY2IwIn19XSwicHJlZGljYXRlVHlwZSI6Imh0dHBzOi8vZG9jcy5weXBpLm9yZy9hdHRlc3RhdGlvbnMvcHVibGlzaC92MSIsInByZWRpY2F0ZSI6bnVsbH0=","signature":"MEQCID8TciW3Rrq82fUQmaw0P9eURoQoUIBXpu4YIrjgxWEiAiAawSb+qNZt27cbMcsuiZP19Xo7rhS0avIqPzY7ZQbWvQ=="}}