@openhands/extensions 0.21.0 → 0.22.0

package/tests/github_automation_helpers.py

@@ -16,7 +16,13 @@ def worker(name, tmp_path, monkeypatch):
     bundle.mkdir()
     for filename, source in manifest["setup"]["bundle"]["files"].items():
         (bundle / filename).write_text((ROOT / source).read_text())
-    for module in ("main", "github_client", "qa_prompt", "worker"):
+    for module in (
+        "agent_conversation",
+        "main",
+        "github_client",
+        "qa_prompt",
+        "worker",
+    ):
         monkeypatch.delitem(sys.modules, module, raising=False)
     monkeypatch.syspath_prepend(str(bundle))
     spec = importlib.util.spec_from_file_location("worker", bundle / "worker.py")

package/tests/test_agent_conversation_dispatch.py

@@ -0,0 +1,180 @@
+import json
+from unittest.mock import MagicMock
+from uuid import NAMESPACE_URL, UUID, uuid5
+
+import agent_conversation
+import github_client
+from openhands.sdk.conversation.state import ConversationExecutionStatus
+
+
+def _dispatcher(monkeypatch):
+    monkeypatch.setenv("AGENT_SERVER_URL", "http://agent")
+    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"})
+    )
+    return agent_conversation.AgentConversationDispatcher()
+
+
+def _state_key(subject):
+    conversation_id = uuid5(NAMESPACE_URL, f"automation-1:{subject}")
+    return f"agent-conversation-{conversation_id}"
+
+
+def _fake_kv(monkeypatch, state):
+    def request(key, method, value=None):
+        if method == "GET":
+            return state.get(key)
+        state[key] = value
+        return {"key": key, "value": value}
+
+    monkeypatch.setattr(agent_conversation, "_kv_request", request)
+
+
+def test_github_secret_falls_back_to_agent_server(monkeypatch):
+    monkeypatch.delenv("REVIEW_TOKEN", raising=False)
+    monkeypatch.setenv("AGENT_SERVER_URL", "http://agent")
+    monkeypatch.setenv("SESSION_API_KEY", "session")
+    secret = MagicMock()
+    secret.get_value.return_value = "saved-token"
+    workspace = MagicMock()
+    workspace.get_secrets.return_value = {"REVIEW_TOKEN": secret}
+    monkeypatch.setattr(
+        "openhands.sdk.workspace.RemoteWorkspace", lambda **kwargs: workspace
+    )
+
+    assert github_client._load_secret("REVIEW_TOKEN") == "saved-token"
+    workspace.get_secrets.assert_called_once_with(["REVIEW_TOKEN"])
+    workspace.reset_client.assert_called_once_with()
+
+
+def test_new_subject_uses_selected_profile_and_persists_mapping(monkeypatch):
+    state = {}
+    _fake_kv(monkeypatch, state)
+    monkeypatch.setattr(agent_conversation, "_register_tools", lambda: None)
+    workspace = MagicMock()
+    workspace.__enter__.return_value = workspace
+    monkeypatch.setattr(
+        agent_conversation, "RemoteWorkspace", lambda **kwargs: workspace
+    )
+    missing = agent_conversation.httpx.HTTPStatusError(
+        "missing",
+        request=MagicMock(),
+        response=MagicMock(status_code=404),
+    )
+    monkeypatch.setattr(
+        agent_conversation.RemoteConversation, "attach", MagicMock(side_effect=missing)
+    )
+    conversation = MagicMock()
+    create = MagicMock(return_value=conversation)
+    monkeypatch.setattr(agent_conversation.RemoteConversation, "create", create)
+
+    with _dispatcher(monkeypatch) as dispatcher:
+        result = dispatcher.deliver("repo:issue:7", "revision-1", "work")
+
+    request = create.call_args.args[1]
+    assert request.agent_profile_id == UUID("11111111-1111-4111-8111-111111111111")
+    assert request.initial_message.run is True
+    assert result["disposition"] == "created"
+    record = state[_state_key("repo:issue:7")]
+    assert record == {
+        "subject": "repo:issue:7",
+        "conversation_id": result["conversation_id"],
+        "delivery": "revision-1",
+    }
+
+
+def test_known_subject_resumes_once_per_delivery(monkeypatch):
+    state = {
+        _state_key("repo:pr:9"): {
+            "subject": "repo:pr:9",
+            "conversation_id": "22222222-2222-4222-8222-222222222222",
+            "delivery": "head-1",
+        }
+    }
+    _fake_kv(monkeypatch, state)
+    monkeypatch.setattr(agent_conversation, "_register_tools", lambda: None)
+    workspace = MagicMock()
+    workspace.__enter__.return_value = workspace
+    monkeypatch.setattr(
+        agent_conversation, "RemoteWorkspace", lambda **kwargs: workspace
+    )
+    conversation = MagicMock()
+    conversation.state.execution_status = ConversationExecutionStatus.FINISHED
+    attach = MagicMock(return_value=conversation)
+    monkeypatch.setattr(agent_conversation.RemoteConversation, "attach", attach)
+    with _dispatcher(monkeypatch) as dispatcher:
+        duplicate = dispatcher.deliver("repo:pr:9", "head-1", "old")
+        resumed = dispatcher.deliver("repo:pr:9", "head-2", "new")
+
+    assert duplicate["disposition"] == "deduplicated"
+    assert resumed["disposition"] == "resumed"
+    conversation.send_message.assert_called_once_with("new")
+    conversation.run.assert_called_once_with(blocking=False)
+
+
+def test_same_delivery_resumes_paused_conversation(monkeypatch):
+    state = {
+        _state_key("repo:pr:9"): {
+            "subject": "repo:pr:9",
+            "conversation_id": "22222222-2222-4222-8222-222222222222",
+            "delivery": "head-1",
+        }
+    }
+    _fake_kv(monkeypatch, state)
+    monkeypatch.setattr(agent_conversation, "_register_tools", lambda: None)
+    workspace = MagicMock()
+    workspace.__enter__.return_value = workspace
+    monkeypatch.setattr(
+        agent_conversation, "RemoteWorkspace", lambda **kwargs: workspace
+    )
+    conversation = MagicMock()
+    conversation.state.execution_status = ConversationExecutionStatus.PAUSED
+    monkeypatch.setattr(
+        agent_conversation.RemoteConversation,
+        "attach",
+        MagicMock(return_value=conversation),
+    )
+
+    with _dispatcher(monkeypatch) as dispatcher:
+        result = dispatcher.deliver("repo:pr:9", "head-1", "old")
+
+    assert result["disposition"] == "resumed"
+    conversation.send_message.assert_not_called()
+    conversation.run.assert_called_once_with(blocking=False)
+
+
+def test_subjects_use_independent_kv_records(monkeypatch):
+    state = {}
+    _fake_kv(monkeypatch, state)
+    monkeypatch.setattr(agent_conversation, "_register_tools", lambda: None)
+    workspace = MagicMock()
+    workspace.__enter__.return_value = workspace
+    monkeypatch.setattr(
+        agent_conversation, "RemoteWorkspace", lambda **kwargs: workspace
+    )
+    missing = agent_conversation.httpx.HTTPStatusError(
+        "missing",
+        request=MagicMock(),
+        response=MagicMock(status_code=404),
+    )
+    monkeypatch.setattr(
+        agent_conversation.RemoteConversation, "attach", MagicMock(side_effect=missing)
+    )
+    monkeypatch.setattr(
+        agent_conversation.RemoteConversation,
+        "create",
+        MagicMock(side_effect=[MagicMock(), MagicMock()]),
+    )
+
+    with _dispatcher(monkeypatch) as dispatcher:
+        dispatcher.deliver("repo:issue:7", "revision-1", "first")
+        dispatcher.deliver("repo:issue:8", "revision-1", "second")
+
+    assert set(state) == {
+        _state_key("repo:issue:7"),
+        _state_key("repo:issue:8"),
+    }

package/tests/test_automation_setup.py

@@ -676,9 +676,9 @@ def test_schema_rejects_content_a_setup_block_must_never_carry() -> None:
     rejected.append(("{{env.GITHUB_TOKEN}}", with_unknown_placeholder))
 
     with_secret_value = deepcopy(entry)
-    with_secret_value["requires"]["integrations"]["github"]["value"] = (
-        "ghp_notarealtokenvalue00"
-    )
+    with_secret_value["requires"]["integrations"]["github"] = {
+        "value": "ghp_notarealtokenvalue00"
+    }
     rejected.append(("value", with_secret_value))
 
     with_repeated_identity = deepcopy(entry)

package/tests/test_github_developer_delivery.py

@@ -0,0 +1,150 @@
+"""Contract tests for independent developer delivery."""
+
+from unittest.mock import Mock
+
+from github_automation_helpers import worker
+
+
+def _developer(tmp_path, monkeypatch):
+    module = worker("github-issue-to-pr", tmp_path, monkeypatch)
+    run = object.__new__(module.IssueToPR)
+    run.config = {
+        "trigger_label": "ready-for-dev",
+        "branch_prefix": "openhands/issue",
+        "review_label": "openhands-review",
+    }
+    run.repository = "owner/repo"
+    run.token_name = "FACTORY_GITHUB_DEVELOPER_TOKEN"
+    run.dispatcher = Mock()
+    run.dependencies_complete = lambda issue: True
+    run.statuses = lambda sha: {}
+    return module, run
+
+
+def test_developer_fans_out_ready_issues_by_priority(tmp_path, monkeypatch):
+    _module, run = _developer(tmp_path, monkeypatch)
+    issues = [
+        {
+            "number": 2,
+            "title": "Normal",
+            "updated_at": "u2",
+            "labels": [{"name": "ready-for-dev"}],
+        },
+        {
+            "number": 1,
+            "title": "High",
+            "updated_at": "u1",
+            "labels": [{"name": "ready-for-dev"}, {"name": "priority:high"}],
+        },
+    ]
+    run.open_issues = lambda: issues
+    run.gh_pages = lambda path: []
+    run.gh = Mock(
+        side_effect=[{"id": 55, "default_branch": "main"}, {"object": {"sha": "base"}}]
+    )
+    submit = Mock(
+        side_effect=lambda **kwargs: {
+            "disposition": "created",
+            "conversation_id": kwargs["subject"],
+        }
+    )
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    assert [call.kwargs["subject"] for call in submit.call_args_list] == [
+        "55:issue:1",
+        "55:issue:2",
+    ]
+    prompt = submit.call_args_list[0].kwargs["prompt"]
+    assert "workspace starts empty" in prompt
+    assert "FACTORY_GITHUB_DEVELOPER_TOKEN" in prompt
+    assert "gh repo clone owner/repo ." in prompt
+
+
+def test_developer_submits_failed_review_as_same_subject(tmp_path, monkeypatch):
+    _module, run = _developer(tmp_path, monkeypatch)
+    issue = {"number": 4, "title": "Feature", "updated_at": "u4", "labels": []}
+    pr = {
+        "number": 8,
+        "head": {"ref": "openhands/issue-4", "sha": "head"},
+        "base": {"ref": "main"},
+        "labels": [],
+    }
+    run.open_issues = lambda: [issue]
+    run.gh_pages = lambda path: [pr]
+    run.statuses = lambda sha: {"software-factory/review": "failure"}
+    run.gh = Mock(
+        side_effect=[{"id": 55, "default_branch": "main"}, {"object": {"sha": "base"}}]
+    )
+    submit = Mock(
+        return_value={"disposition": "created", "conversation_id": "conversation"}
+    )
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    assert submit.call_args.kwargs["subject"] == "55:issue:4"
+    assert submit.call_args.kwargs["delivery"] == "4:head"
+    prompt = submit.call_args.kwargs["prompt"]
+    assert "Revise existing PR #8 at exact head `head`" in prompt
+    assert "check out the existing remote branch `openhands/issue-4`" in prompt
+    assert "do not open another pull request" in prompt
+
+
+def test_developer_continues_after_one_submission_fails(tmp_path, monkeypatch):
+    _module, run = _developer(tmp_path, monkeypatch)
+    issues = [
+        {
+            "number": 1,
+            "title": "First",
+            "updated_at": "u1",
+            "labels": [{"name": "ready-for-dev"}],
+        },
+        {
+            "number": 2,
+            "title": "Second",
+            "updated_at": "u2",
+            "labels": [{"name": "ready-for-dev"}],
+        },
+    ]
+    run.open_issues = lambda: issues
+    run.gh_pages = lambda path: []
+    run.gh = Mock(
+        side_effect=[{"id": 55, "default_branch": "main"}, {"object": {"sha": "base"}}]
+    )
+    submit = Mock(
+        side_effect=[
+            RuntimeError("unavailable"),
+            {"disposition": "created", "conversation_id": "second"},
+        ]
+    )
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    assert [call.kwargs["subject"] for call in submit.call_args_list] == [
+        "55:issue:1",
+        "55:issue:2",
+    ]
+
+
+def test_developer_skips_open_pr_awaiting_review(tmp_path, monkeypatch):
+    _module, run = _developer(tmp_path, monkeypatch)
+    issue = {"number": 4, "title": "Feature", "labels": [{"name": "ready-for-dev"}]}
+    pr = {
+        "number": 8,
+        "head": {"ref": "openhands/issue-4", "sha": "head"},
+        "labels": [{"name": "openhands-review"}],
+    }
+    run.open_issues = lambda: [issue]
+    run.gh_pages = lambda path: [pr]
+    run.gh = Mock(
+        side_effect=[{"id": 55, "default_branch": "main"}, {"object": {"sha": "base"}}]
+    )
+    submit = Mock()
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    submit.assert_not_called()

package/tests/test_github_reviewer_delivery.py

@@ -0,0 +1,110 @@
+"""Contract tests for delegated GitHub PR review."""
+
+from pathlib import Path
+from unittest.mock import Mock
+
+from github_automation_helpers import worker
+
+
+def _reviewer(tmp_path, monkeypatch):
+    module = worker("github-pr-reviewer", tmp_path, monkeypatch)
+    run = object.__new__(module.PullRequestReviewer)
+    run.config = {"trigger_label": "openhands-review"}
+    run.repository = "owner/repo"
+    run.token = "token"
+    run.token_name = "FACTORY_GITHUB_REVIEWER_TOKEN"
+    run.dispatcher = Mock()
+    return module, run
+
+
+def test_reviewer_submits_each_labeled_exact_head(tmp_path, monkeypatch):
+    module, run = _reviewer(tmp_path, monkeypatch)
+    prs = [
+        {
+            "number": 2,
+            "head": {"sha": "head-2"},
+            "labels": [{"name": "openhands-review"}],
+        },
+        {"number": 1, "head": {"sha": "head-1"}, "labels": []},
+    ]
+    run.gh_pages = lambda path: prs
+    run.gh = Mock(side_effect=[{"id": 99}, prs[0]])
+    monkeypatch.setattr(
+        module.workflow,
+        "_latest_trigger_label_event",
+        lambda *args: {"id": 7, "created_at": "now"},
+    )
+    submit = Mock(
+        return_value={"disposition": "created", "conversation_id": "conversation"}
+    )
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    assert submit.call_args.kwargs["subject"] == "99:pr:2"
+    assert submit.call_args.kwargs["delivery"] == "7:head-2"
+    prompt = submit.call_args.kwargs["prompt"]
+    assert "publish the review directly to GitHub" in prompt
+    assert "software-factory/review" in prompt
+    assert "software-factory/tests" in prompt
+    assert "FACTORY_GITHUB_REVIEWER_TOKEN" in prompt
+    assert "gh auth setup-git" in prompt
+    assert "GIT_TERMINAL_PROMPT=0" in prompt
+    assert "Never paste JSON artifacts" in prompt
+
+
+def test_reviewer_ignores_unlabeled_prs(tmp_path, monkeypatch):
+    _module, run = _reviewer(tmp_path, monkeypatch)
+    run.gh_pages = lambda path: [{"number": 1, "labels": [], "head": {"sha": "head"}}]
+    run.gh = Mock(return_value={"id": 99})
+    submit = Mock()
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    submit.assert_not_called()
+
+
+def test_reviewer_continues_after_one_submission_fails(tmp_path, monkeypatch):
+    module, run = _reviewer(tmp_path, monkeypatch)
+    prs = [
+        {
+            "number": number,
+            "labels": [{"name": "openhands-review"}],
+            "head": {"sha": f"head-{number}"},
+        }
+        for number in (1, 2)
+    ]
+    run.gh_pages = lambda path: prs
+    run.gh = Mock(side_effect=[{"id": 99}, *prs])
+    monkeypatch.setattr(
+        module.workflow,
+        "_latest_trigger_label_event",
+        lambda *args: {"id": 7, "created_at": "now"},
+    )
+    submit = Mock(
+        side_effect=[
+            RuntimeError("temporary failure"),
+            {"disposition": "created", "conversation_id": "conversation"},
+        ]
+    )
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    assert submit.call_count == 2
+
+
+def test_reviewer_scanner_has_no_conversation_or_runtime_code():
+    source = (
+        Path(__file__).resolve().parents[1]
+        / "skills/github-pr-reviewer/scripts/worker.py"
+    ).read_text()
+    for forbidden in (
+        "RemoteConversation",
+        "RemoteWorkspace",
+        "AGENT_SERVER_URL",
+        "SESSION_API_KEY",
+        "AUTOMATION_CONVERSATION_ID",
+    ):
+        assert forbidden not in source

package/tests/test_github_triage_delivery.py

@@ -1,53 +1,90 @@
 """Contract tests for independent triage delivery."""
 
-import json
 from unittest.mock import Mock
 
-import pytest
 from github_automation_helpers import worker
 
 
-@pytest.mark.parametrize(
-    "ready,criteria",
-    [(True, ["One observable result"]), (False, ["Clarify account ownership"])],
-)
-def test_triage_preserves_labels_and_only_readies_clear_work(
-    tmp_path, monkeypatch, ready, criteria
-):
-    cls = worker("github-issue-triage", tmp_path, monkeypatch).IssueTriage
+def _triage(tmp_path, monkeypatch, issues):
+    module = worker("github-issue-triage", tmp_path, monkeypatch)
+    cls = module.IssueTriage
     run = object.__new__(cls)
-    issue = {
-        "number": 1,
-        "title": "A small feature",
-        "body": "",
-        "labels": [{"name": "enhancement"}],
-    }
-    run.open_issues = lambda: [issue]
-    run.gh_pages = lambda path: []
+    run.repository = "owner/repo"
+    run.token_name = "GITHUB_PERSONAL_ACCESS_TOKEN"
+    run.dispatcher = Mock()
+    run.open_issues = lambda: issues
     run.dependencies_complete = lambda issue: True
-    result = {
-        "ready": ready,
-        "priority": "normal",
-        "acceptance_criteria": criteria,
-        "rationale": "Small independent change",
-    }
-    run.evidence = tmp_path
-    run.conversation = Mock()
-    run.conversation.run.side_effect = lambda **kwargs: (
-        tmp_path / "triage.json"
-    ).write_text(json.dumps(result))
-    calls = []
-    run.gh = lambda *args: calls.append(args)
-    run.comment = lambda *args: calls.append(("comment", *args))
+    run.gh = lambda method, path, body=None: {"id": 9876}
+    run.gh_pages = lambda path: []
+    return module, run
 
-    run.run()
 
-    updates = [call for call in calls if call[0] == "PATCH"]
-    assert bool(updates) is ready
-    if ready:
-        assert set(updates[0][2]["labels"]) == {
-            "enhancement",
-            "priority:normal",
-            "ready-for-dev",
+def test_triage_submits_each_changed_issue_as_agent_work(tmp_path, monkeypatch):
+    issues = [
+        {"number": 2, "title": "Second", "body": "B", "labels": []},
+        {"number": 1, "title": "First", "body": "A", "labels": []},
+    ]
+    _module, run = _triage(tmp_path, monkeypatch, issues)
+    submit = Mock(
+        side_effect=lambda **kwargs: {
+            "disposition": "created",
+            "conversation_id": kwargs["subject"],
         }
-    assert criteria[0] in next(call[2] for call in calls if call[0] == "comment")
+    )
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    assert [call.kwargs["subject"] for call in submit.call_args_list] == [
+        "9876:issue:1",
+        "9876:issue:2",
+    ]
+    assert "Do not implement code" in submit.call_args_list[0].kwargs["prompt"]
+    assert "GITHUB_PERSONAL_ACCESS_TOKEN" in submit.call_args_list[0].kwargs["prompt"]
+
+
+def test_triage_continues_after_one_submission_fails(tmp_path, monkeypatch):
+    issues = [
+        {"number": 1, "title": "First", "body": "A", "labels": []},
+        {"number": 2, "title": "Second", "body": "B", "labels": []},
+    ]
+    _module, run = _triage(tmp_path, monkeypatch, issues)
+    submit = Mock(
+        side_effect=[
+            RuntimeError("unavailable"),
+            {"disposition": "created", "conversation_id": "second"},
+        ]
+    )
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    assert [call.kwargs["subject"] for call in submit.call_args_list] == [
+        "9876:issue:1",
+        "9876:issue:2",
+    ]
+
+
+def test_triage_skips_ready_blocked_and_unchanged_issues(tmp_path, monkeypatch):
+    issues = [
+        {
+            "number": 1,
+            "title": "Ready",
+            "body": "",
+            "labels": [{"name": "ready-for-dev"}],
+        },
+        {"number": 2, "title": "Blocked", "body": "", "labels": []},
+        {"number": 3, "title": "Unchanged", "body": "", "labels": []},
+    ]
+    module, run = _triage(tmp_path, monkeypatch, issues)
+    run.dependencies_complete = lambda issue: issue["number"] != 2
+    marker = module.hashlib.sha256(
+        module.json.dumps(["Unchanged", "", []], sort_keys=True).encode()
+    ).hexdigest()
+    run.gh_pages = lambda path: [{"id": 10, "body": f"<!-- triage-source:{marker} -->"}]
+    submit = Mock()
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    submit.assert_not_called()