@openhands/extensions 0.25.0 → 0.26.0

package/tests/test_agent_conversation_dispatch.py

@@ -94,6 +94,9 @@ def test_new_subject_uses_selected_profile_and_persists_mapping(monkeypatch):
         "subject": "repo:issue:7",
         "conversation_id": result["conversation_id"],
         "delivery": "revision-1",
+        # A caller with no revision identity records an empty head, which keeps
+        # the dedupe keyed on `delivery` alone.
+        "head": "",
     }
 
 
@@ -177,6 +180,89 @@ def test_same_delivery_resumes_only_inactive_conversation(
         conversation.run.assert_not_called()
 
 
+def test_new_delivery_on_a_running_same_head_is_not_a_second_review(monkeypatch):
+    """A fresh trigger for a head already under review must not start a review.
+
+    This is the duplicate the trigger-keyed delivery alone allowed: a second
+    review request (or a label re-applied after the bot's own handoff) produces a
+    new delivery key, which would send a new turn and publish a second review of
+    the head an in-flight conversation is already reviewing.
+    """
+    state = {
+        _state_key("repo:pr:9"): {
+            "subject": "repo:pr:9",
+            "conversation_id": "22222222-2222-4222-8222-222222222222",
+            "delivery": "42:head-2",
+            "head": "head-2",
+        }
+    }
+    _fake_kv(monkeypatch, state)
+    monkeypatch.setattr(agent_conversation, "_register_tools", lambda: None)
+    workspace = MagicMock()
+    workspace.__enter__.return_value = workspace
+    workspace.get_secrets.return_value = {}
+    monkeypatch.setattr(
+        agent_conversation, "RemoteWorkspace", lambda **kwargs: workspace
+    )
+    conversation = MagicMock()
+    conversation.state.execution_status = ConversationExecutionStatus.RUNNING
+    monkeypatch.setattr(
+        agent_conversation.RemoteConversation,
+        "attach",
+        MagicMock(return_value=conversation),
+    )
+
+    with _dispatcher(monkeypatch) as dispatcher:
+        result = dispatcher.deliver("repo:pr:9", "43:head-2", "again", head="head-2")
+
+    assert result["disposition"] == "in_progress"
+    conversation.send_message.assert_not_called()
+    conversation.run.assert_not_called()
+    # The revision the live turn is working on is left recorded, not overwritten
+    # by the trigger that arrived beside it.
+    assert state[_state_key("repo:pr:9")]["delivery"] == "42:head-2"
+
+
+def test_new_delivery_on_a_running_new_head_still_sends_a_turn(monkeypatch):
+    """A moved head is new work, so the running conversation gets the new turn."""
+    state = {
+        _state_key("repo:pr:9"): {
+            "subject": "repo:pr:9",
+            "conversation_id": "22222222-2222-4222-8222-222222222222",
+            "delivery": "42:head-1",
+            "head": "head-1",
+        }
+    }
+    _fake_kv(monkeypatch, state)
+    monkeypatch.setattr(agent_conversation, "_register_tools", lambda: None)
+    workspace = MagicMock()
+    workspace.__enter__.return_value = workspace
+    workspace.get_secrets.return_value = {}
+    monkeypatch.setattr(
+        agent_conversation, "RemoteWorkspace", lambda **kwargs: workspace
+    )
+    conversation = MagicMock()
+    conversation.state.execution_status = ConversationExecutionStatus.RUNNING
+    monkeypatch.setattr(
+        agent_conversation.RemoteConversation,
+        "attach",
+        MagicMock(return_value=conversation),
+    )
+
+    with _dispatcher(monkeypatch) as dispatcher:
+        result = dispatcher.deliver("repo:pr:9", "43:head-2", "next", head="head-2")
+
+    assert result["disposition"] == "resumed"
+    conversation.send_message.assert_called_once_with("next")
+    conversation.run.assert_called_once_with(blocking=False)
+    assert state[_state_key("repo:pr:9")] == {
+        "subject": "repo:pr:9",
+        "conversation_id": result["conversation_id"],
+        "delivery": "43:head-2",
+        "head": "head-2",
+    }
+
+
 def test_subjects_use_independent_kv_records(monkeypatch):
     state = {}
     _fake_kv(monkeypatch, state)
@@ -209,3 +295,129 @@ def test_subjects_use_independent_kv_records(monkeypatch):
         _state_key("repo:issue:7"),
         _state_key("repo:issue:8"),
     }
+
+
+# --- OpenHands Cloud and Enterprise: conversations go through the OpenHands API
+
+
+class _FakeCloud:
+    """The OpenHands API's conversations, as the dispatcher uses them."""
+
+    def __init__(self, conversation=None):
+        self.conversation = conversation
+        self.started = []
+        self.sent = []
+
+    def get(self, conversation_id):
+        return self.conversation
+
+    def start(self, conversation_id, profile_id, title, prompt):
+        self.started.append({"id": str(conversation_id), "profile": str(profile_id)})
+
+    def send(self, conversation, prompt):
+        self.sent.append(prompt)
+
+    def run(self, conversation):
+        pass
+
+
+def _cloud_dispatcher(monkeypatch, cloud):
+    monkeypatch.delenv("AGENT_SERVER_URL", raising=False)
+    monkeypatch.setenv("SESSION_API_KEY", "session")
+    monkeypatch.setenv(
+        "AUTOMATION_AGENT_PROFILE_ID", "11111111-1111-4111-8111-111111111111"
+    )
+    monkeypatch.setenv(
+        "AUTOMATION_EVENT_PAYLOAD", json.dumps({"automation_id": "automation-1"})
+    )
+    monkeypatch.setattr(agent_conversation, "CloudConversations", lambda: cloud)
+    return agent_conversation.AgentConversationDispatcher()
+
+
+def test_cloud_run_starts_a_new_subject_with_the_selected_profile(monkeypatch):
+    # Arrange
+    state = {}
+    _fake_kv(monkeypatch, state)
+    cloud = _FakeCloud()
+
+    # Act
+    with _cloud_dispatcher(monkeypatch, cloud) as dispatcher:
+        result = dispatcher.deliver("repo:pr:7", "revision-1", "review it")
+
+    # Assert
+    assert result["disposition"] == "created"
+    [started] = cloud.started
+    assert started["profile"] == "11111111-1111-4111-8111-111111111111"
+    assert state[_state_key("repo:pr:7")]["conversation_id"] == started["id"]
+
+
+def test_cloud_run_does_not_start_a_second_conversation_while_one_is_starting(
+    monkeypatch,
+):
+    # Arrange - the first delivery's conversation is not listed by the API yet
+    state = {}
+    _fake_kv(monkeypatch, state)
+    cloud = _FakeCloud()
+    with _cloud_dispatcher(monkeypatch, cloud) as dispatcher:
+        dispatcher.deliver("repo:pr:7", "revision-1", "review it", head="sha-1")
+        recorded = dict(state[_state_key("repo:pr:7")])
+
+        # Act - a new revision arrives before it is
+        result = dispatcher.deliver(
+            "repo:pr:7", "revision-2", "review again", head="sha-2"
+        )
+
+    # Assert - nothing is started, and the record is left for the next trigger
+    assert result["disposition"] == "in_progress"
+    assert len(cloud.started) == 1
+    assert state[_state_key("repo:pr:7")] == recorded
+
+
+def test_cloud_run_sends_a_new_revision_to_the_subjects_conversation(monkeypatch):
+    # Arrange
+    state = {
+        _state_key("repo:pr:7"): {
+            "conversation_id": "22222222-2222-4222-8222-222222222222",
+            "delivery": "revision-1",
+            "head": "sha-1",
+        }
+    }
+    _fake_kv(monkeypatch, state)
+    cloud = _FakeCloud({"sandbox_status": "RUNNING", "execution_status": "idle"})
+
+    # Act
+    with _cloud_dispatcher(monkeypatch, cloud) as dispatcher:
+        result = dispatcher.deliver(
+            "repo:pr:7", "revision-2", "review again", head="sha-2"
+        )
+
+    # Assert
+    assert result["disposition"] == "resumed"
+    assert cloud.sent == ["review again"]
+    assert cloud.started == []
+
+
+def test_cloud_run_replaces_a_conversation_whose_sandbox_is_gone(monkeypatch):
+    # Arrange
+    gone = "22222222-2222-4222-8222-222222222222"
+    state = {
+        _state_key("repo:pr:7"): {
+            "conversation_id": gone,
+            "delivery": "revision-1",
+            "head": "sha-1",
+        }
+    }
+    _fake_kv(monkeypatch, state)
+    cloud = _FakeCloud({"sandbox_status": "MISSING", "execution_status": None})
+
+    # Act
+    with _cloud_dispatcher(monkeypatch, cloud) as dispatcher:
+        result = dispatcher.deliver(
+            "repo:pr:7", "revision-2", "review again", head="sha-2"
+        )
+
+    # Assert - the API does not start an id twice, so the subject gets a new one
+    assert result["disposition"] == "created"
+    [started] = cloud.started
+    assert started["id"] != gone
+    assert state[_state_key("repo:pr:7")]["conversation_id"] == started["id"]

package/tests/test_apps_catalog.py

@@ -0,0 +1,26 @@
+import json
+import subprocess
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def test_apps_catalog_is_valid_and_package_export_matches():
+    entries = json.loads((ROOT / "apps/catalog.json").read_text())
+    assert isinstance(entries, list)
+    assert len({entry["id"] for entry in entries}) == len(entries)
+    for entry in entries:
+        assert set(entry) == {"id", "name", "description", "source", "manifest", "beta"}
+        assert entry["id"] and entry["source"].startswith("./apps/")
+        assert entry["manifest"].endswith("/canvas-extension.json")
+        assert entry["beta"] is True
+    subprocess.run(
+        [
+            "node",
+            "--input-type=module",
+            "-e",
+            "import { APPS_CATALOG } from './index.js'; if (!Array.isArray(APPS_CATALOG)) process.exit(1)",
+        ],
+        cwd=ROOT,
+        check=True,
+    )

package/tests/test_automation_setup.py

@@ -625,6 +625,25 @@ def _iter_strings(node):
         yield node
 
 
+def _scenario_template_versions(bundle: dict) -> set[str]:
+    """Every template version a fixture pins, wherever it appears."""
+    versions = set()
+
+    def walk(node) -> None:
+        if isinstance(node, dict):
+            template = node.get("template")
+            if isinstance(template, dict) and "version" in template:
+                versions.add(template["version"])
+            for value in node.values():
+                walk(value)
+        elif isinstance(node, list):
+            for item in node:
+                walk(item)
+
+    walk(bundle["scenarios"])
+    return versions
+
+
 def _scenarios(kind: str):
     """Every fixture scenario carrying the given block, as test params."""
     for path in sorted(FIXTURE_DIR.glob("*.json")):
@@ -787,6 +806,31 @@ def test_multi_action_fixture_scenarios_name_the_selected_variant(
         assert scenario.get("selectedAction") in actions, scenario["id"]
 
 
+@pytest.mark.parametrize("fixture_path", list(_fixture_bundles()))
+def test_fixture_template_versions_match_the_entry_to_pin_the_bump(
+    fixture_path: Path,
+) -> None:
+    """A fixture pins the template version the host will send, so it moves with
+    the entry. Pinning a stale version passes until the version is bumped, and
+    then every scenario in the fixture fails at once - the bump, not the
+    behavior, is what changed."""
+    bundle = _load(fixture_path)
+    entry = _entry_for(bundle)
+
+    expected = set()
+    if "version" in entry:
+        expected.add(entry["version"])
+    if "version" in entry.get("setup", {}).get("bundle", {}):
+        expected.add(entry["setup"]["bundle"]["version"])
+
+    pinned = _scenario_template_versions(bundle)
+
+    assert pinned <= expected, (
+        f"{fixture_path.stem}: fixture pins template version(s) {sorted(pinned)} "
+        f"but {entry['id']} declares {sorted(expected)}"
+    )
+
+
 @pytest.mark.parametrize("entry_path", list(_setup_paths()))
 def test_the_declared_features_match_the_archetype(entry_path: Path) -> None:
     """A bundle needs a deployment that runs a client-supplied tarball; a prompt

package/tests/test_check_pr_description.py

@@ -6,10 +6,9 @@ import sys
 from pathlib import Path
 
 
-def _load_prod_module():
+def _load(name: str, script_name: str):
     repo_root = Path(__file__).resolve().parents[1]
-    script_path = repo_root / ".github" / "scripts" / "check_pr_description.py"
-    name = "check_pr_description"
+    script_path = repo_root / ".github" / "scripts" / script_name
     spec = importlib.util.spec_from_file_location(name, script_path)
     assert spec and spec.loader
     mod = importlib.util.module_from_spec(spec)
@@ -18,9 +17,12 @@ def _load_prod_module():
     return mod
 
 
-_prod = _load_prod_module()
+# `check_pr_description` resolves its sibling `markdown_sections` itself, so no
+# preloading is needed here and this file genuinely exercises that contract.
+_prod = _load("check_pr_description", "check_pr_description.py")
 validate_pr_body = _prod.validate_pr_body
 body_from_event = _prod.body_from_event
+extract_human_note = _prod.extract_human_note
 extract_linked_issue_numbers = _prod.extract_linked_issue_numbers
 validate_linked_issue_ready = _prod.validate_linked_issue_ready
 fetch_issue_details = _prod.fetch_issue_details
@@ -28,9 +30,11 @@ fetch_issue_details = _prod.fetch_issue_details
 
 VALID_BODY = """<!-- Keep this PR as draft until it is ready for review. -->
 
-<!-- AI/LLM agents: be concise and specific. Do not check the box below. -->
+HUMAN:
 
-- [ ] A human has tested these changes.
+I checked this change and it does what the PR says.
+
+AGENT:
 
 ---
 
@@ -64,6 +68,85 @@ def test_valid_pr_body_passes():
     assert validate_pr_body(VALID_BODY) == []
 
 
+def test_first_visible_line_must_be_human_marker():
+    body = VALID_BODY.replace("HUMAN:", "## Why\n\nSomething.\n\nHUMAN:", 1)
+
+    errors = validate_pr_body(body)
+
+    assert any("first visible line" in e for e in errors)
+
+
+def test_human_note_must_clear_the_minimum_length():
+    body = VALID_BODY.replace(
+        "I checked this change and it does what the PR says.", "Looks good."
+    )
+
+    errors = validate_pr_body(body)
+
+    assert any("human-written note" in e for e in errors)
+
+
+def test_missing_human_section_is_reported():
+    body = VALID_BODY.replace("HUMAN:", "", 1)
+
+    errors = validate_pr_body(body)
+
+    assert any("first visible line" in e for e in errors)
+    assert any("human-written note" in e for e in errors)
+
+
+def test_agent_marker_must_be_kept():
+    body = VALID_BODY.replace("AGENT:", "", 1)
+
+    errors = validate_pr_body(body)
+
+    assert any("AGENT:" in e for e in errors)
+
+
+def test_quoting_the_template_markers_in_a_fence_does_not_satisfy_the_gate():
+    # A body whose only HUMAN:/AGENT: markers are quoted inside a code fence has
+    # no real human attestation: the markers must appear outside fenced code.
+    body = VALID_BODY.replace(
+        "HUMAN:\n\nI checked this change and it does what the PR says.\n\nAGENT:",
+        "```text\nHUMAN:\n\nfill this in yourself\n\nAGENT:\n```",
+    )
+
+    errors = validate_pr_body(body)
+
+    assert any("first visible line" in e for e in errors)
+    assert any("human-written note" in e for e in errors)
+
+
+def test_human_note_stops_at_the_agent_marker():
+    # Text after AGENT: must not count toward the human note.
+    body = VALID_BODY.replace(
+        "I checked this change and it does what the PR says.",
+        "ok\n\nAGENT:\n\n" + "agent padding " * 5,
+    )
+
+    assert extract_human_note(body) == "ok"
+    assert any("human-written note" in e for e in validate_pr_body(body))
+
+
+def test_human_note_and_sections_survive_crlf_bodies():
+    body = VALID_BODY.replace("\n", "\r\n")
+
+    assert validate_pr_body(body) == []
+
+
+def test_template_fields_must_be_outside_fenced_code_blocks():
+    # Quoting the template's headings in a fence must not satisfy the sections.
+    body = (
+        "HUMAN:\n\nI reviewed this change carefully and it works as described.\n\n"
+        "AGENT:\n\n```markdown\n## Why\n\nx\n\n## Summary\n\n- y\n\n"
+        "## How to Test\n\nz\n```\n"
+    )
+
+    errors = validate_pr_body(body)
+
+    assert any("Keep the `## Why`" in e for e in errors)
+
+
 def test_required_template_fields_must_be_present_and_filled():
     how_to_test = "## How to Test\n\nRun `uv run --group test pytest tests/`."
     body = VALID_BODY.replace(how_to_test, "## How to Test\n\n<!-- TODO -->")