@openhands/extensions 0.1.0 → 0.2.0

package/tests/test_catalogs.py

@@ -0,0 +1,109 @@
+import json
+import re
+import subprocess
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def load_catalog_entries(relative_path: str):
+    entries = []
+    for entry_path in sorted((ROOT / relative_path).glob("*.json")):
+        entry = json.loads(entry_path.read_text())
+        assert entry["id"] == entry_path.stem
+        entries.append(entry)
+    return entries
+
+
+def test_catalog_ids_are_unique_and_automations_reference_existing_integrations():
+    integrations = load_catalog_entries("integrations/catalog")
+    automations = load_catalog_entries("automations/catalog")
+
+    integration_ids = [entry["id"] for entry in integrations]
+    automation_ids = [entry["id"] for entry in automations]
+
+    assert len(integration_ids) == len(set(integration_ids))
+    assert len(automation_ids) == len(set(automation_ids))
+
+    known_integration_ids = set(integration_ids)
+    for automation in automations:
+        assert automation["requiredIntegrationIds"]
+        missing_ids = (
+            set(automation["requiredIntegrationIds"]) - known_integration_ids
+        )
+        assert missing_ids == set()
+
+
+def test_catalog_entries_have_required_fields():
+    for entry in load_catalog_entries("integrations/catalog"):
+        assert entry["id"]
+        assert entry["name"]
+        assert entry["description"]
+        assert entry["kind"] in {"mcp", "http"}
+        assert entry["iconBg"]
+        assert entry["connectionOptions"]
+        assert entry["defaultConnectionOptionId"]
+        for option in entry["connectionOptions"]:
+            assert option["id"]
+            assert option["provider"] in {"mcp", "http"}
+            assert option["auth"]["strategy"] in {
+                "none",
+                "api_key",
+                "bearer",
+                "basic",
+                "oauth2",
+            }
+            if option["provider"] == "mcp":
+                assert option["transport"]["kind"] in {"stdio", "shttp", "sse"}
+                if option["transport"]["kind"] == "stdio":
+                    assert option["transport"]["serverName"]
+                    assert option["transport"]["command"]
+                    assert isinstance(option["transport"]["args"], list)
+                else:
+                    assert option["transport"]["url"].startswith("https://")
+
+    for entry in load_catalog_entries("automations/catalog"):
+        assert entry["id"]
+        assert entry["name"]
+        assert entry["prompt"]
+        assert entry["exampleImplementation"]
+        assert isinstance(entry["popularityRank"], int)
+        assert isinstance(entry["estimatedSetupMinutes"], int)
+
+
+def test_credential_fields_have_helper_text_and_link():
+    """All password fields must have helperText plus a link (either a helperLink field or a
+    markdown link embedded in helperText) so users know how to get credentials."""
+    markdown_link_re = re.compile(r"\[.+?\]\(https://[^)]+\)")
+
+    for entry in load_catalog_entries("integrations/catalog"):
+        for option in entry["connectionOptions"]:
+            transport = option.get("transport", {})
+            for field_group in ("envFields", "argFields"):
+                for field in transport.get(field_group, []):
+                    if field.get("type") == "password":
+                        field_key = field.get("key", "<unknown>")
+                        assert "helperText" in field, (
+                            f"{entry['id']}: password field '{field_key}' is missing helperText"
+                        )
+                        assert field["helperText"], (
+                            f"{entry['id']}: password field '{field_key}' has empty helperText"
+                        )
+                        has_helper_link = field.get("helperLink", "").startswith("https://")
+                        has_inline_link = bool(markdown_link_re.search(field["helperText"]))
+                        assert has_helper_link or has_inline_link, (
+                            f"{entry['id']}: password field '{field_key}' must have a helperLink "
+                            f"or a markdown link in helperText"
+                        )
+
+
+def test_node_package_exports_catalogs():
+    script = """
+      import { INTEGRATION_CATALOG, AUTOMATION_CATALOG } from './index.js';
+      if (!Array.isArray(INTEGRATION_CATALOG) || INTEGRATION_CATALOG.length === 0) process.exit(1);
+      if (!Array.isArray(AUTOMATION_CATALOG) || AUTOMATION_CATALOG.length === 0) process.exit(1);
+      if (!INTEGRATION_CATALOG.some((entry) => entry.id === 'github')) process.exit(1);
+      if (!AUTOMATION_CATALOG.some((entry) => entry.id === 'github-pr-reviewer')) process.exit(1);
+    """
+    subprocess.run(["node", "--input-type=module", "-e", script], cwd=ROOT, check=True)

package/tests/test_code_review_risk_evaluation.py

@@ -0,0 +1,94 @@
+"""Test that risk/safety evaluation is integrated into the unified code review skill."""
+
+from pathlib import Path
+
+
+def get_repo_root():
+    return Path(__file__).parent.parent
+
+
+def get_code_review_skill():
+    return (get_repo_root() / "skills" / "code-review" / "SKILL.md").read_text()
+
+
+def get_risk_evaluation_reference():
+    return (
+        get_repo_root()
+        / "skills"
+        / "code-review"
+        / "references"
+        / "risk-evaluation.md"
+    ).read_text()
+
+
+class TestRiskEvaluationReference:
+    """Verify the risk-evaluation.md reference file is complete."""
+
+    def test_reference_file_exists(self):
+        path = (
+            get_repo_root()
+            / "skills"
+            / "code-review"
+            / "references"
+            / "risk-evaluation.md"
+        )
+        assert path.exists()
+
+    def test_has_all_risk_levels(self):
+        content = get_risk_evaluation_reference()
+        assert "Low Risk" in content
+        assert "Medium Risk" in content
+        assert "High Risk" in content
+
+    def test_has_risk_factors(self):
+        content = get_risk_evaluation_reference()
+        factors = [
+            "Pattern conformance",
+            "Security sensitivity",
+            "Infrastructure dependencies",
+            "Blast radius",
+            "Core system impact",
+        ]
+        for factor in factors:
+            assert factor in content, f"Missing risk factor: {factor}"
+
+    def test_has_high_risk_escalation_guidance(self):
+        content = get_risk_evaluation_reference()
+        assert "not auto-merg" in content.lower()
+        assert "human" in content.lower()
+
+    def test_has_repo_specific_risk_rules(self):
+        content = get_risk_evaluation_reference()
+        assert "AGENTS.md" in content
+        assert "repo-specific" in content.lower() or "Repo-specific" in content
+
+    def test_has_risk_assessment_output_format(self):
+        content = get_risk_evaluation_reference()
+        assert "Risk Assessment" in content
+
+
+class TestCodeReviewSkillReferencesRisk:
+    """Verify the unified code-review skill references the risk evaluation."""
+
+    def test_has_risk_evaluation_scenario(self):
+        content = get_code_review_skill()
+        assert "Risk and Safety Evaluation" in content
+
+    def test_references_risk_evaluation_file(self):
+        content = get_code_review_skill()
+        assert "references/risk-evaluation.md" in content
+
+    def test_risk_section_appears_after_dependency_section(self):
+        content = get_code_review_skill()
+        dep_pos = content.index("8. **Dependency Changes**")
+        risk_pos = content.index("9. **Risk and Safety Evaluation**")
+        assert risk_pos > dep_pos
+
+    def test_always_include_risk_instruction(self):
+        content = get_code_review_skill()
+        assert "Always include the" in content
+        assert "Risk and Safety Evaluation" in content
+
+    def test_has_risk_assessment_in_output_format(self):
+        content = get_code_review_skill()
+        assert "RISK ASSESSMENT" in content

package/tests/test_issue_duplicate_checker.py

@@ -0,0 +1,240 @@
+import importlib.util
+import io
+import urllib.error
+from pathlib import Path
+
+import pytest
+
+
+ROOT = Path(__file__).resolve().parents[1]
+PLUGIN_DIR = ROOT / "plugins" / "issue-duplicate-checker" / "scripts"
+
+
+def load_script(name: str):
+    path = PLUGIN_DIR / f"{name}.py"
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    assert spec.loader is not None
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_action_shell_blocks_do_not_interpolate_expressions_directly():
+    action_path = ROOT / "plugins" / "issue-duplicate-checker" / "action.yml"
+    lines = action_path.read_text().splitlines()
+    in_block = False
+    block_indent = 0
+    for line_number, line in enumerate(lines, start=1):
+        stripped = line.lstrip()
+        indent = len(line) - len(stripped)
+        if in_block and stripped and indent <= block_indent:
+            in_block = False
+        if stripped.startswith(("run:", "script:")):
+            block_scalar = stripped.split(":", 1)[1].strip()
+            if block_scalar.startswith(("|", ">")):
+                in_block = True
+                block_indent = indent
+            continue
+        assert not (in_block and "${{" in line), (
+            f"Move GitHub expression on line {line_number} into env before using it"
+        )
+
+
+def test_normalize_result_preserves_model_should_comment_false():
+    script = load_script("issue_duplicate_check_openhands")
+
+    result = script.normalize_result(
+        {
+            "should_comment": False,
+            "is_duplicate": True,
+            "auto_close_candidate": True,
+            "classification": "duplicate",
+            "confidence": "high",
+            "canonical_issue_number": 123,
+            "candidate_issues": [{"number": 123}],
+        }
+    )
+
+    assert result["should_comment"] is False
+    assert result["auto_close_candidate"] is False
+
+
+def test_github_headers_require_token(monkeypatch):
+    script = load_script("issue_duplicate_check_openhands")
+    monkeypatch.delenv("GITHUB_TOKEN", raising=False)
+
+    with pytest.raises(
+        RuntimeError,
+        match="GITHUB_TOKEN environment variable is required",
+    ):
+        script.github_headers()
+
+    monkeypatch.setenv("GITHUB_TOKEN", "token")
+    headers = script.github_headers()
+    assert headers["Authorization"] == "Bearer token"
+
+
+def test_issue_check_request_json_raises_structured_http_error(monkeypatch):
+    script = load_script("issue_duplicate_check_openhands")
+
+    def fake_urlopen(*args, **kwargs):
+        raise urllib.error.HTTPError(
+            url="https://api.example.test/example",
+            code=403,
+            msg="Forbidden",
+            hdrs=None,
+            fp=io.BytesIO(b'{"message":"rate limited"}'),
+        )
+
+    monkeypatch.setattr(script.urllib.request, "urlopen", fake_urlopen)
+
+    with pytest.raises(script.HTTPError) as exc_info:
+        script.request_json("https://api.example.test", "/example")
+
+    assert exc_info.value.status_code == 403
+    assert exc_info.value.url == "https://api.example.test/example"
+
+
+def test_parse_agent_json_extracts_fenced_json():
+    script = load_script("issue_duplicate_check_openhands")
+
+    result = script.parse_agent_json(
+        'Here is the result:\n```json\n'
+        '{"classification":"duplicate","confidence":"high"}\n```'
+    )
+
+    assert result == {"classification": "duplicate", "confidence": "high"}
+
+
+def test_normalize_result_guards_auto_close_and_infers_canonical_issue():
+    script = load_script("issue_duplicate_check_openhands")
+
+    overlapping = script.normalize_result(
+        {
+            "should_comment": True,
+            "is_duplicate": False,
+            "auto_close_candidate": True,
+            "classification": "overlapping-scope",
+            "confidence": "high",
+            "candidate_issues": [{"number": 10}],
+        }
+    )
+    assert overlapping["should_comment"] is True
+    assert overlapping["auto_close_candidate"] is False
+
+    low_confidence = script.normalize_result(
+        {
+            "should_comment": True,
+            "is_duplicate": True,
+            "auto_close_candidate": True,
+            "classification": "duplicate",
+            "confidence": "low",
+            "candidate_issues": [{"number": 11}],
+        }
+    )
+    assert low_confidence["should_comment"] is False
+    assert low_confidence["auto_close_candidate"] is False
+
+    inferred = script.normalize_result(
+        {
+            "should_comment": True,
+            "is_duplicate": True,
+            "auto_close_candidate": True,
+            "classification": "duplicate",
+            "confidence": "high",
+            "canonical_issue_number": None,
+            "candidate_issues": [{"number": "12"}],
+        }
+    )
+    assert inferred["auto_close_candidate"] is True
+    assert inferred["canonical_issue_number"] == 12
+
+
+def test_build_prompt_includes_required_schema_keys():
+    script = load_script("issue_duplicate_check_openhands")
+
+    prompt = script.build_prompt(
+        "OpenHands/extensions",
+        {
+            "number": 123,
+            "title": "Duplicate bug",
+            "body": "Looks related",
+            "html_url": "https://github.com/OpenHands/extensions/issues/123",
+        },
+    )
+
+    for key in [
+        "should_comment",
+        "is_duplicate",
+        "auto_close_candidate",
+        "classification",
+        "confidence",
+        "canonical_issue_number",
+        "candidate_issues",
+    ]:
+        assert key in prompt
+
+
+def test_find_latest_auto_close_comment_uses_newest_auto_close_marker():
+    script = load_script("auto_close_duplicate_issues")
+
+    latest, canonical = script.find_latest_auto_close_comment(
+        [
+            {
+                "id": 1,
+                "created_at": "2026-01-01T00:00:00Z",
+                "body": "<!-- openhands-duplicate-check canonical=10 auto-close=true -->",
+            },
+            {
+                "id": 2,
+                "created_at": "2026-01-03T00:00:00Z",
+                "body": "<!-- openhands-duplicate-check canonical=20 auto-close=false -->",
+            },
+            {
+                "id": 3,
+                "created_at": None,
+                "body": "<!-- openhands-duplicate-check canonical=30 auto-close=true -->",
+            },
+            {
+                "id": 4,
+                "created_at": "2026-01-02T00:00:00Z",
+                "body": "<!-- openhands-duplicate-check canonical=40 auto-close=true -->",
+            },
+        ]
+    )
+
+    assert latest["id"] == 4
+    assert canonical == 40
+
+
+def test_request_json_raises_structured_http_error(monkeypatch):
+    script = load_script("auto_close_duplicate_issues")
+    monkeypatch.setenv("GITHUB_TOKEN", "token")
+
+    def fake_urlopen(*args, **kwargs):
+        raise urllib.error.HTTPError(
+            url="https://api.github.com/example",
+            code=404,
+            msg="Not Found",
+            hdrs=None,
+            fp=io.BytesIO(b'{"message":"missing"}'),
+        )
+
+    monkeypatch.setattr(script.urllib.request, "urlopen", fake_urlopen)
+
+    with pytest.raises(script.HTTPError) as exc_info:
+        script.request_json("/example")
+
+    assert exc_info.value.status_code == 404
+    assert exc_info.value.path == "/example"
+
+
+def test_fetch_issue_returns_none_on_404(monkeypatch):
+    script = load_script("auto_close_duplicate_issues")
+
+    def fake_request_json(path):
+        raise script.HTTPError("GET", path, 404, "missing")
+
+    monkeypatch.setattr(script, "request_json", fake_request_json)
+
+    assert script.fetch_issue("OpenHands/extensions", 123) is None

package/tests/test_openhands_api_python.py

@@ -0,0 +1,152 @@
+import importlib.util
+import sys
+from pathlib import Path
+
+
+def _load_openhands_api_module():
+    skill_path = Path(__file__).parent.parent / "skills" / "openhands-api" / "scripts" / "openhands_api.py"
+    spec = importlib.util.spec_from_file_location("openhands_api", skill_path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["openhands_api"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def test_app_conversation_start_builds_v1_payload(monkeypatch):
+    mod = _load_openhands_api_module()
+    OpenHandsAPI = mod.OpenHandsAPI
+
+    captured = {}
+
+    class FakeResp:
+        def raise_for_status(self):
+            return None
+
+        def json(self):
+            return {"id": "task-1", "status": "WORKING"}
+
+    class FakeClient:
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+
+        def post(self, url, json=None, timeout=None):
+            captured["url"] = url
+            captured["json"] = json
+            captured["timeout"] = timeout
+            return FakeResp()
+
+        def close(self):
+            return None
+
+    monkeypatch.setattr(mod.httpx, "Client", lambda **kwargs: FakeClient(**kwargs))
+
+    api = OpenHandsAPI(api_key="k", base_url="https://example.com/")
+    resp = api.app_conversation_start(
+        initial_message="hi",
+        selected_repository="o/r",
+        selected_branch="main",
+        title="Test title",
+        run=False,
+    )
+
+    assert resp == {"id": "task-1", "status": "WORKING"}
+    assert captured["url"] == "https://example.com/api/v1/app-conversations"
+    assert captured["timeout"] == 120
+    assert captured["json"] == {
+        "initial_message": {
+            "role": "user",
+            "content": [{"type": "text", "text": "hi"}],
+            "run": False,
+        },
+        "selected_repository": "o/r",
+        "selected_branch": "main",
+        "title": "Test title",
+    }
+
+
+def test_app_conversations_get_batch_passes_ids(monkeypatch):
+    mod = _load_openhands_api_module()
+    OpenHandsAPI = mod.OpenHandsAPI
+
+    captured = {}
+
+    class FakeResp:
+        def raise_for_status(self):
+            return None
+
+        def json(self):
+            return [{"id": "conv-1"}]
+
+    class FakeClient:
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+
+        def get(self, url, params=None):
+            captured["url"] = url
+            captured["params"] = params
+            return FakeResp()
+
+        def close(self):
+            return None
+
+    monkeypatch.setattr(mod.httpx, "Client", lambda **kwargs: FakeClient(**kwargs))
+
+    api = OpenHandsAPI(api_key="k", base_url="https://example.com")
+    conversations = api.app_conversations_get_batch(ids=["conv-1", "conv-2"])
+
+    assert conversations == [{"id": "conv-1"}]
+    assert captured["url"] == "https://example.com/api/v1/app-conversations"
+    assert captured["params"] == {"ids": ["conv-1", "conv-2"]}
+
+
+def test_poll_start_task_until_ready_uses_start_task_endpoint(monkeypatch):
+    mod = _load_openhands_api_module()
+    OpenHandsAPI = mod.OpenHandsAPI
+
+    states = [
+        {"id": "task-1", "status": "WORKING"},
+        {"id": "task-1", "status": "READY", "app_conversation_id": "conv-1"},
+    ]
+    call_count = {"sleep": 0}
+
+    class FakeClient:
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+
+        def get(self, url, params=None):
+            class FakeResp:
+                def raise_for_status(self_nonlocal):
+                    return None
+
+                def json(self_nonlocal):
+                    return [states.pop(0)]
+
+            return FakeResp()
+
+        def close(self):
+            return None
+
+    monkeypatch.setattr(mod.httpx, "Client", lambda **kwargs: FakeClient(**kwargs))
+    monkeypatch.setattr(mod.time, "sleep", lambda *_args, **_kwargs: call_count.__setitem__("sleep", call_count["sleep"] + 1))
+
+    api = OpenHandsAPI(api_key="k", base_url="https://example.com")
+    ready = api.poll_start_task_until_ready("task-1", timeout_s=10, poll_interval_s=0.01, backoff_factor=1.0)
+
+    assert ready == {"id": "task-1", "status": "READY", "app_conversation_id": "conv-1"}
+    assert call_count["sleep"] == 1
+
+
+def test_legacy_alias_still_exists(monkeypatch):
+    mod = _load_openhands_api_module()
+
+    class FakeClient:
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+
+        def close(self):
+            return None
+
+    monkeypatch.setattr(mod.httpx, "Client", lambda **kwargs: FakeClient(**kwargs))
+
+    api = mod.OpenHandsV1API(api_key="k")
+    assert isinstance(api, mod.OpenHandsAPI)

package/tests/test_plugin_manifest.py

@@ -0,0 +1,83 @@
+"""Test that all plugin.json manifests are valid and Claude Code compatible."""
+
+import json
+from pathlib import Path
+
+import pytest
+
+
+def get_plugins_directory():
+    """Get the path to the plugins directory."""
+    test_dir = Path(__file__).parent
+    return test_dir.parent / "plugins"
+
+
+def get_all_plugin_manifests():
+    """Yield (plugin_name, manifest_path) for every plugin with a .plugin/plugin.json."""
+    plugins_dir = get_plugins_directory()
+    for plugin_dir in sorted(plugins_dir.iterdir()):
+        if not plugin_dir.is_dir() or plugin_dir.name.startswith("."):
+            continue
+        manifest = plugin_dir / ".plugin" / "plugin.json"
+        if manifest.exists():
+            yield plugin_dir.name, manifest
+
+
+REQUIRED_FIELDS = ["name", "description", "author", "version"]
+
+
+@pytest.fixture(params=list(get_all_plugin_manifests()), ids=lambda p: p[0])
+def plugin_manifest(request):
+    """Parametrized fixture returning (name, path, parsed_json) for each plugin."""
+    name, path = request.param
+    data = json.loads(path.read_text())
+    return name, path, data
+
+
+def test_plugin_has_required_fields(plugin_manifest):
+    name, path, data = plugin_manifest
+    for field in REQUIRED_FIELDS:
+        assert field in data, (
+            f"Plugin '{name}' is missing required field '{field}' in {path}"
+        )
+
+
+def test_plugin_author_is_object(plugin_manifest):
+    """Claude Code requires 'author' to be an object with at least a 'name' key."""
+    name, path, data = plugin_manifest
+    author = data.get("author")
+    assert isinstance(author, dict), (
+        f"Plugin '{name}': 'author' must be an object (got {type(author).__name__}). "
+        f"Use {{\"name\": \"...\", \"email\": \"...\"}} format for Claude Code compatibility."
+    )
+    assert "name" in author, (
+        f"Plugin '{name}': 'author' object must contain a 'name' field."
+    )
+
+
+def test_plugin_json_is_valid(plugin_manifest):
+    """Ensure plugin.json is valid JSON with expected types."""
+    name, path, data = plugin_manifest
+    assert isinstance(data.get("name"), str), f"Plugin '{name}': 'name' must be a string"
+    assert isinstance(data.get("version"), str), f"Plugin '{name}': 'version' must be a string"
+    assert isinstance(data.get("description"), str), f"Plugin '{name}': 'description' must be a string"
+
+
+def test_all_plugins_have_manifest():
+    """Ensure every plugin directory has a .plugin/plugin.json manifest."""
+    plugins_dir = get_plugins_directory()
+    plugin_dirs = [
+        d.name
+        for d in plugins_dir.iterdir()
+        if d.is_dir() and not d.name.startswith(".")
+    ]
+    assert len(plugin_dirs) > 0, "No plugin directories found"
+
+    missing = [
+        name
+        for name in plugin_dirs
+        if not (plugins_dir / name / ".plugin" / "plugin.json").exists()
+    ]
+    assert len(missing) == 0, (
+        f"Plugins missing .plugin/plugin.json: {', '.join(missing)}"
+    )