mirror of
https://github.com/Sea-Haven-Industries/open-swe.git
synced 2026-09-30 17:23:15 +00:00
209132d355
* wip(rebuild): core reliability spine
- remove PR-babysitting (ci_autofix + ci_monitor graph + webhook wiring)
- dispatch core: agent/dispatch.py with multitask_strategy=interrupt +
durability=sync + completion webhook; reroute all webhook + plan triggers;
drop the racy in-process lock + is_thread_active busy-check
- completion webhook: agent/completion.py + /webhooks/run-complete loopback
route for failure/timeout replies (idempotent)
Co-authored-by: open-swe[bot]
* feat(rebuild): async tools, reconcile, shared http timeouts, assembly tuning
Parallel batch on top of the reliability spine:
- async-ify all 24 tools (drop asyncio.run; requests->httpx); re-implement the
http_request/fetch_url SSRF + DNS-rebinding defense httpx-natively and harden
the IP check to 'not is_global' (+ IPv4-mapped unwrap)
- reconcile.py: stale pending-run sweep (threads.search -> per-thread runs.list
-> cancel_many), wired into the scheduler graph via task='reconcile'
- shared DEFAULT_HTTP_TIMEOUT (agent/utils/http.py) on every bare
httpx.AsyncClient() across utils/dashboard/webapp/middleware
- run budget: MODEL_CALL_RECURSION_LIMIT 5000->250
- fix stale OpenAI->Anthropic fallback id (claude-opus-4-5 -> 4-8)
- drop redundant custom repair middleware (deepagents auto-adds PatchToolCalls)
- confirm tool-result eviction + summarization auto-wired via backend
- slim system prompt ~8% (full harness-profile rewrite deferred)
Co-authored-by: open-swe[bot]
* feat(rebuild): harness-profile prompt + split webhooks out of webapp
- prompt.py: own the system prompt via a registered harness profile
(OPEN_SWE_SHARED_BASE, kept neutral so the read-only reviewer/analyzer that
share it stay safe), registered across all 4 providers; per-thread values
stay in construct_system_prompt. Assembled main-agent prompt ~6.8k -> ~3.1k
tokens (~55% smaller); de-duped PR/commit/suite/force-push guidance; dropped
ALL-CAPS markers.
- webapp.py 3325 -> 1890 LOC: moved 14 per-source handlers into
agent/webhooks/{linear,slack,github}.py; webapp re-exports them for the
routes + tests; moved handlers reach shared helpers via the webapp namespace
to preserve the test suite's monkeypatch targets.
Full suite: 1168 passing, lint clean.
Co-authored-by: open-swe[bot]
* Restore MODEL_CALL_RECURSION_LIMIT to 5000 for long-running tasks
Reverts the 250 cap from the run-budget change — long-running tasks legitimately
need many model calls. The notify_step_limit_reached safety net still fires if a
run does hit the cap, so runs end with a signal either way.
Co-authored-by: open-swe[bot]
* fix: address PR review (auth, SSRF, interrupted status, redirect headers)
- completion.py: drop `interrupted` from failure statuses — with
multitask_strategy=interrupt a follow-up ends the prior run as interrupted,
which is healthy, not a failure to report. [open-swe]
- /webhooks/run-complete: shared-secret auth — dispatch appends ?token= when
RUN_COMPLETE_WEBHOOK_SECRET is set; route verifies via hmac.compare_digest.
[corridor-security]
- SSRF: extract the URL validator to agent/utils/url_safety.py and apply it
before server-side image fetches in multimodal.fetch_image_block.
[corridor-security]
- http_request: preserve caller headers/extensions across redirect hops instead
of dropping them on the first hop. [open-swe]
Co-authored-by: open-swe[bot]
* chore: remove REBUILD_PLAN.md (planning doc, not needed in the repo)
Co-authored-by: open-swe[bot]
* fix: fail closed on run-complete webhook auth when secret unset
Corridor follow-up: verify_run_complete_token returns False (not True) when
RUN_COMPLETE_WEBHOOK_SECRET is unset, so the public route is never
unauthenticated. Logs a startup warning when the secret is absent, and dispatch
skips registering the webhook when there's no secret (no rejected callbacks).
Co-authored-by: open-swe[bot]
---------
Co-authored-by: open-swe[bot] <open-swe@users.noreply.github.com>
395 lines
14 KiB
Python
395 lines
14 KiB
Python
"""Tests for the opened / ready_for_review auto-review webhook handlers."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
from unittest.mock import AsyncMock, MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
from agent import webapp
|
|
|
|
|
|
def _pr_payload(
|
|
*,
|
|
action: str,
|
|
draft: bool,
|
|
author: str = "alice",
|
|
private: bool | None = None,
|
|
) -> dict[str, Any]:
|
|
repository: dict[str, Any] = {"owner": {"login": "lc"}, "name": "repo", "id": 123}
|
|
if private is not None:
|
|
repository["private"] = private
|
|
return {
|
|
"action": action,
|
|
"repository": repository,
|
|
"pull_request": {
|
|
"number": 7,
|
|
"html_url": "https://github.com/lc/repo/pull/7",
|
|
"title": "T",
|
|
"draft": draft,
|
|
"user": {"login": author},
|
|
"head": {"sha": "headsha", "ref": "feat-x"},
|
|
"base": {"sha": "basesha", "ref": "main"},
|
|
},
|
|
"sender": {"login": author, "id": 1},
|
|
}
|
|
|
|
|
|
def _patch_dispatch_deps(monkeypatch: pytest.MonkeyPatch, fake_client: Any) -> None:
|
|
monkeypatch.setattr(
|
|
webapp,
|
|
"get_github_app_installation_token_with_expiry",
|
|
AsyncMock(return_value=("token", None)),
|
|
)
|
|
monkeypatch.setattr(webapp, "_ensure_thread_exists_for_metadata", AsyncMock(return_value=True))
|
|
monkeypatch.setattr(webapp, "cache_github_token_for_thread", MagicMock())
|
|
monkeypatch.setattr(webapp, "set_reviewer_thread_metadata", AsyncMock())
|
|
monkeypatch.setattr(webapp, "get_client", lambda url: fake_client)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_ready_non_draft_triggers_run(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
fake_client = MagicMock()
|
|
fake_client.runs.create = AsyncMock()
|
|
_patch_dispatch_deps(monkeypatch, fake_client)
|
|
monkeypatch.setattr(webapp, "get_profile", AsyncMock(return_value=None))
|
|
monkeypatch.setattr(webapp, "get_team_settings", AsyncMock(return_value={}))
|
|
|
|
await webapp.process_github_pr_ready(_pr_payload(action="opened", draft=False))
|
|
|
|
fake_client.runs.create.assert_awaited_once()
|
|
_, kwargs = fake_client.runs.create.await_args
|
|
assert kwargs["config"]["configurable"]["source"] == "github"
|
|
assert kwargs["config"]["configurable"]["pr_number"] == 7
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_ready_public_repo_uses_scoped_reviewer_token(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
fake_client = MagicMock()
|
|
fake_client.runs.create = AsyncMock()
|
|
get_token = AsyncMock(return_value=("scoped-token", "expires"))
|
|
monkeypatch.setattr(webapp, "get_github_app_installation_token_with_expiry", get_token)
|
|
monkeypatch.setattr(webapp, "_ensure_thread_exists_for_metadata", AsyncMock(return_value=True))
|
|
cache_token = MagicMock()
|
|
monkeypatch.setattr(webapp, "cache_github_token_for_thread", cache_token)
|
|
monkeypatch.setattr(webapp, "set_reviewer_thread_metadata", AsyncMock())
|
|
monkeypatch.setattr(webapp, "get_client", lambda url: fake_client)
|
|
monkeypatch.setattr(webapp, "get_profile", AsyncMock(return_value=None))
|
|
monkeypatch.setattr(webapp, "get_team_settings", AsyncMock(return_value={}))
|
|
|
|
await webapp.process_github_pr_ready(_pr_payload(action="opened", draft=False, private=False))
|
|
|
|
get_token.assert_awaited_once_with(repository_ids=[123])
|
|
_, kwargs = fake_client.runs.create.await_args
|
|
assert kwargs["config"]["configurable"]["repo_private"] is False
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_ready_private_repo_uses_full_reviewer_token(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
fake_client = MagicMock()
|
|
fake_client.runs.create = AsyncMock()
|
|
get_token = AsyncMock(return_value=("full-token", "expires"))
|
|
monkeypatch.setattr(webapp, "get_github_app_installation_token_with_expiry", get_token)
|
|
monkeypatch.setattr(webapp, "_ensure_thread_exists_for_metadata", AsyncMock(return_value=True))
|
|
monkeypatch.setattr(webapp, "cache_github_token_for_thread", MagicMock())
|
|
monkeypatch.setattr(webapp, "set_reviewer_thread_metadata", AsyncMock())
|
|
monkeypatch.setattr(webapp, "get_client", lambda url: fake_client)
|
|
monkeypatch.setattr(webapp, "get_profile", AsyncMock(return_value=None))
|
|
monkeypatch.setattr(webapp, "get_team_settings", AsyncMock(return_value={}))
|
|
|
|
await webapp.process_github_pr_ready(_pr_payload(action="opened", draft=False, private=True))
|
|
|
|
get_token.assert_awaited_once_with()
|
|
_, kwargs = fake_client.runs.create.await_args
|
|
assert kwargs["config"]["configurable"]["repo_private"] is True
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_ready_for_review_triggers_run(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
fake_client = MagicMock()
|
|
fake_client.runs.create = AsyncMock()
|
|
_patch_dispatch_deps(monkeypatch, fake_client)
|
|
monkeypatch.setattr(webapp, "_get_thread_metadata_safe", AsyncMock(return_value=None))
|
|
monkeypatch.setattr(webapp, "get_profile", AsyncMock(return_value=None))
|
|
monkeypatch.setattr(webapp, "get_team_settings", AsyncMock(return_value={}))
|
|
|
|
await webapp.process_github_pr_ready(_pr_payload(action="ready_for_review", draft=False))
|
|
|
|
fake_client.runs.create.assert_awaited_once()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_ready_for_review_skips_when_head_already_reviewed(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
fake_client = MagicMock()
|
|
fake_client.runs.create = AsyncMock()
|
|
set_metadata = AsyncMock()
|
|
get_token = AsyncMock(return_value=("token", None))
|
|
monkeypatch.setattr(webapp, "get_github_app_installation_token_with_expiry", get_token)
|
|
monkeypatch.setattr(webapp, "set_reviewer_thread_metadata", set_metadata)
|
|
monkeypatch.setattr(
|
|
webapp,
|
|
"_get_thread_metadata_safe",
|
|
AsyncMock(
|
|
return_value={
|
|
"kind": "reviewer",
|
|
"watch": False,
|
|
"last_reviewed_sha": "headsha",
|
|
}
|
|
),
|
|
)
|
|
monkeypatch.setattr(webapp, "get_client", lambda url: fake_client)
|
|
monkeypatch.setattr(webapp, "get_profile", AsyncMock(return_value=None))
|
|
monkeypatch.setattr(webapp, "get_team_settings", AsyncMock(return_value={}))
|
|
|
|
await webapp.process_github_pr_ready(_pr_payload(action="ready_for_review", draft=False))
|
|
|
|
fake_client.runs.create.assert_not_called()
|
|
get_token.assert_not_awaited()
|
|
set_metadata.assert_awaited_once()
|
|
assert set_metadata.await_args.kwargs["watch"] is True
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_ready_for_review_uses_re_review_after_previous_review(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
fake_client = MagicMock()
|
|
fake_client.runs.create = AsyncMock()
|
|
_patch_dispatch_deps(monkeypatch, fake_client)
|
|
monkeypatch.setattr(
|
|
webapp,
|
|
"_get_thread_metadata_safe",
|
|
AsyncMock(
|
|
return_value={
|
|
"kind": "reviewer",
|
|
"watch": False,
|
|
"last_reviewed_sha": "oldsha",
|
|
}
|
|
),
|
|
)
|
|
monkeypatch.setattr(webapp, "get_profile", AsyncMock(return_value=None))
|
|
monkeypatch.setattr(webapp, "get_team_settings", AsyncMock(return_value={}))
|
|
|
|
await webapp.process_github_pr_ready(_pr_payload(action="ready_for_review", draft=False))
|
|
|
|
fake_client.runs.create.assert_awaited_once()
|
|
_, kwargs = fake_client.runs.create.await_args
|
|
configurable = kwargs["config"]["configurable"]
|
|
assert configurable["re_review"] is True
|
|
assert configurable["last_reviewed_sha"] == "oldsha"
|
|
assert configurable["head_sha"] == "headsha"
|
|
assert "marked ready for review" in kwargs["input"]["messages"][0]["content"]
|
|
head_sha_writes = [
|
|
c.kwargs.get("head_sha")
|
|
for c in webapp.set_reviewer_thread_metadata.await_args_list
|
|
if c.kwargs.get("head_sha") is not None
|
|
]
|
|
assert "headsha" in head_sha_writes
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_ready_draft_user_override_off_wins_over_team_on(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
fake_client = MagicMock()
|
|
fake_client.runs.create = AsyncMock()
|
|
_patch_dispatch_deps(monkeypatch, fake_client)
|
|
monkeypatch.setattr(
|
|
webapp,
|
|
"get_profile",
|
|
AsyncMock(return_value={"login": "alice", "review_draft_prs": False}),
|
|
)
|
|
monkeypatch.setattr(
|
|
webapp, "get_team_settings", AsyncMock(return_value={"review_draft_prs": True})
|
|
)
|
|
|
|
await webapp.process_github_pr_ready(_pr_payload(action="opened", draft=True))
|
|
|
|
fake_client.runs.create.assert_not_called()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_ready_draft_user_override_on_wins_over_team_off(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
fake_client = MagicMock()
|
|
fake_client.runs.create = AsyncMock()
|
|
_patch_dispatch_deps(monkeypatch, fake_client)
|
|
monkeypatch.setattr(
|
|
webapp,
|
|
"get_profile",
|
|
AsyncMock(return_value={"login": "alice", "review_draft_prs": True}),
|
|
)
|
|
monkeypatch.setattr(
|
|
webapp,
|
|
"get_team_settings",
|
|
AsyncMock(return_value={"review_draft_prs": False}),
|
|
)
|
|
|
|
await webapp.process_github_pr_ready(_pr_payload(action="opened", draft=True))
|
|
|
|
fake_client.runs.create.assert_awaited_once()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_ready_draft_user_default_falls_back_to_team_on(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
fake_client = MagicMock()
|
|
fake_client.runs.create = AsyncMock()
|
|
_patch_dispatch_deps(monkeypatch, fake_client)
|
|
# User profile exists but review_draft_prs is None — inherit team default.
|
|
monkeypatch.setattr(
|
|
webapp,
|
|
"get_profile",
|
|
AsyncMock(return_value={"login": "alice", "review_draft_prs": None}),
|
|
)
|
|
monkeypatch.setattr(
|
|
webapp, "get_team_settings", AsyncMock(return_value={"review_draft_prs": True})
|
|
)
|
|
|
|
await webapp.process_github_pr_ready(_pr_payload(action="opened", draft=True))
|
|
|
|
fake_client.runs.create.assert_awaited_once()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_ready_draft_no_profile_falls_back_to_team_off(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
fake_client = MagicMock()
|
|
fake_client.runs.create = AsyncMock()
|
|
_patch_dispatch_deps(monkeypatch, fake_client)
|
|
# External contributor — inherit team default (off).
|
|
monkeypatch.setattr(webapp, "get_profile", AsyncMock(return_value=None))
|
|
monkeypatch.setattr(
|
|
webapp,
|
|
"get_team_settings",
|
|
AsyncMock(return_value={"review_draft_prs": False}),
|
|
)
|
|
|
|
await webapp.process_github_pr_ready(_pr_payload(action="opened", draft=True))
|
|
|
|
fake_client.runs.create.assert_not_called()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pr_ready_draft_no_profile_falls_back_to_team_on(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
fake_client = MagicMock()
|
|
fake_client.runs.create = AsyncMock()
|
|
_patch_dispatch_deps(monkeypatch, fake_client)
|
|
monkeypatch.setattr(webapp, "get_profile", AsyncMock(return_value=None))
|
|
monkeypatch.setattr(
|
|
webapp, "get_team_settings", AsyncMock(return_value={"review_draft_prs": True})
|
|
)
|
|
|
|
await webapp.process_github_pr_ready(_pr_payload(action="opened", draft=True))
|
|
|
|
fake_client.runs.create.assert_awaited_once()
|
|
|
|
|
|
def _converted_to_draft_payload(author: str = "alice") -> dict[str, Any]:
|
|
return {
|
|
"action": "converted_to_draft",
|
|
"repository": {"owner": {"login": "lc"}, "name": "repo"},
|
|
"pull_request": {
|
|
"number": 7,
|
|
"head": {"ref": "feat-x"},
|
|
"user": {"login": author},
|
|
},
|
|
}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_converted_to_draft_disables_watch_when_drafts_off(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
captured: list[Any] = []
|
|
|
|
async def fake_set(thread_id: str, **kwargs: Any) -> None:
|
|
captured.append((thread_id, kwargs))
|
|
|
|
with (
|
|
patch(
|
|
"agent.webapp._get_thread_metadata_safe",
|
|
new_callable=AsyncMock,
|
|
return_value={"kind": "reviewer", "watch": True},
|
|
),
|
|
patch(
|
|
"agent.webapp.get_profile",
|
|
new_callable=AsyncMock,
|
|
return_value={"login": "alice", "review_draft_prs": False},
|
|
),
|
|
patch(
|
|
"agent.webapp.get_team_settings",
|
|
new_callable=AsyncMock,
|
|
return_value={"review_draft_prs": False},
|
|
),
|
|
patch("agent.webapp.set_reviewer_thread_metadata", side_effect=fake_set),
|
|
):
|
|
await webapp.process_github_pr_close(_converted_to_draft_payload())
|
|
assert captured and captured[0][1]["watch"] is False
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_converted_to_draft_keeps_watch_when_author_drafts_on(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
fake_set = AsyncMock()
|
|
with (
|
|
patch(
|
|
"agent.webapp._get_thread_metadata_safe",
|
|
new_callable=AsyncMock,
|
|
return_value={"kind": "reviewer", "watch": True},
|
|
),
|
|
patch(
|
|
"agent.webapp.get_profile",
|
|
new_callable=AsyncMock,
|
|
return_value={"login": "alice", "review_draft_prs": True},
|
|
),
|
|
patch(
|
|
"agent.webapp.get_team_settings",
|
|
new_callable=AsyncMock,
|
|
return_value={"review_draft_prs": False},
|
|
),
|
|
patch("agent.webapp.set_reviewer_thread_metadata", new=fake_set),
|
|
):
|
|
await webapp.process_github_pr_close(_converted_to_draft_payload())
|
|
fake_set.assert_not_called()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_converted_to_draft_keeps_watch_when_team_default_drafts_on(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
fake_set = AsyncMock()
|
|
with (
|
|
patch(
|
|
"agent.webapp._get_thread_metadata_safe",
|
|
new_callable=AsyncMock,
|
|
return_value={"kind": "reviewer", "watch": True},
|
|
),
|
|
# Author inherits team default — team has drafts on.
|
|
patch(
|
|
"agent.webapp.get_profile",
|
|
new_callable=AsyncMock,
|
|
return_value={"login": "alice", "review_draft_prs": None},
|
|
),
|
|
patch(
|
|
"agent.webapp.get_team_settings",
|
|
new_callable=AsyncMock,
|
|
return_value={"review_draft_prs": True},
|
|
),
|
|
patch("agent.webapp.set_reviewer_thread_metadata", new=fake_set),
|
|
):
|
|
await webapp.process_github_pr_close(_converted_to_draft_payload())
|
|
fake_set.assert_not_called()
|