mirror of
https://github.com/Sea-Haven-Industries/open-swe.git
synced 2026-09-30 13:53:15 +00:00
2b01652754
* Adopt upstream modular webhook skeleton (#1621) Apply the durable-interrupt-dispatch refactor: split the monolithic webapp.py into a thin routing layer plus per-source handlers in webhooks/{github,slack,linear}.py, and add completion.py, dispatch.py, and reconcile.py. Reconcile fork divergence by keeping the Bedrock/ Fireworks cross-provider fallback, the no-agent-attribution prompt policy, the dashboard-handoff re-export, and the Slack channel-info cache. ci_autofix is restored on the new dispatch model in a later commit. Refs: #80 * Port fork webhook security delta onto modular handlers Re-apply the fork's security customizations that #1621 did not carry: Linear webhook replay protection (freshness window on the signed webhookTimestamp), per-repo token-cache binding threaded through the thread token resolvers, the INTERNAL_BOT_LOGINS self-check in the review-finding-reply path, and a user-mapping cache refresh before email resolution on the issue and PR-comment paths (multi-replica staleness). Existing fork security tests pass unchanged. Refs: #80 * Restore CI auto-fix on the modular dispatch model Bring back ci_autofix.py and the ci_monitor graph that #1621 deleted, re-wiring the fork's security-reviewed PR-babysitting onto the new structure: the CI-event, autofix-toggle, and review-feedback handlers move into webhooks/github.py and the github_webhook router re-gains the check_run/check_suite/workflow_run/status routing plus the autofix command and actionable-review branches. Auto-fix runs now dispatch through dispatch_agent_run (durability + completion webhook) while keeping the deliberate batch-while-busy skip-rule via get_thread_active_status. Restore langgraph.json's ci_monitor entry and the fork autofix tests (dispatch mock + import paths re-pointed). Refs: #80 * Reformat and update docs for the modular webhook split Point CLAUDE.md and deploy/MIGRATION.md at the new webhooks/ modules and the dispatch/completion/reconcile contract, and mark the user-mapping cache-refresh fix as applied on the GitHub handlers. Refs: #80 * Restore reject backstop for autofix dispatch A burst of near-simultaneous CI events for one head SHA can slip past the busy-check before the dedupe SHA is recorded, so dispatch the autofix path with multitask_strategy=reject (dev's prior platform default) to drop duplicate concurrent creates instead of letting them interrupt each other. Also make the completion failure-reply dedup claim-then-post and drop the unreachable interrupted branch. --------- Co-authored-by: amoussa1229 <166072409+amoussa1229@users.noreply.github.com>
168 lines
6.4 KiB
Python
168 lines
6.4 KiB
Python
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
from unittest.mock import AsyncMock
|
|
|
|
import pytest
|
|
|
|
from agent import completion
|
|
|
|
|
|
class _FakeThreads:
|
|
def __init__(self, metadata: dict[str, Any]) -> None:
|
|
self._metadata = metadata
|
|
self.updates: list[dict[str, Any]] = []
|
|
|
|
async def get(self, thread_id: str) -> dict[str, Any]:
|
|
return {"thread_id": thread_id, "metadata": self._metadata}
|
|
|
|
async def update(self, *, thread_id: str, metadata: dict[str, Any]) -> None:
|
|
self.updates.append(metadata)
|
|
|
|
|
|
class _FakeClient:
|
|
def __init__(self, metadata: dict[str, Any]) -> None:
|
|
self.threads = _FakeThreads(metadata)
|
|
|
|
|
|
def _slack_metadata() -> dict[str, Any]:
|
|
return {
|
|
"source": "slack",
|
|
"source_context": {"slack_thread": {"channel_id": "C1", "thread_ts": "123.45"}},
|
|
}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_error_status_posts_slack_failure_reply(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
client = _FakeClient(_slack_metadata())
|
|
monkeypatch.setattr(completion, "langgraph_client", lambda: client)
|
|
reply = AsyncMock(return_value=True)
|
|
monkeypatch.setattr(completion, "post_slack_thread_reply", reply)
|
|
|
|
result = await completion.handle_run_completion({"thread_id": "t1", "status": "error"})
|
|
|
|
assert result["status"] == "ok"
|
|
reply.assert_awaited_once()
|
|
args = reply.await_args.args
|
|
assert args[0] == "C1"
|
|
assert args[1] == "123.45"
|
|
assert client.threads.updates == [{"failure_reply_posted": True}]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_success_status_is_ignored(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
client = _FakeClient(_slack_metadata())
|
|
monkeypatch.setattr(completion, "langgraph_client", lambda: client)
|
|
reply = AsyncMock(return_value=True)
|
|
monkeypatch.setattr(completion, "post_slack_thread_reply", reply)
|
|
|
|
result = await completion.handle_run_completion({"thread_id": "t1", "status": "success"})
|
|
|
|
assert result["status"] == "ignored"
|
|
reply.assert_not_called()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_idempotent_when_already_replied(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
metadata = _slack_metadata()
|
|
metadata["failure_reply_posted"] = True
|
|
client = _FakeClient(metadata)
|
|
monkeypatch.setattr(completion, "langgraph_client", lambda: client)
|
|
reply = AsyncMock(return_value=True)
|
|
monkeypatch.setattr(completion, "post_slack_thread_reply", reply)
|
|
|
|
result = await completion.handle_run_completion({"thread_id": "t1", "status": "timeout"})
|
|
|
|
assert result["status"] == "ignored"
|
|
reply.assert_not_called()
|
|
assert client.threads.updates == []
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_linear_source_comments_on_issue(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
client = _FakeClient({"source": "linear", "source_context": {"linear_issue": {"id": "iss_1"}}})
|
|
monkeypatch.setattr(completion, "langgraph_client", lambda: client)
|
|
comment = AsyncMock(return_value=True)
|
|
monkeypatch.setattr(completion, "comment_on_linear_issue", comment)
|
|
|
|
result = await completion.handle_run_completion({"thread_id": "t1", "status": "timeout"})
|
|
|
|
assert result["status"] == "ok"
|
|
comment.assert_awaited_once()
|
|
assert comment.await_args.args[0] == "iss_1"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_missing_thread_id_is_ignored() -> None:
|
|
result = await completion.handle_run_completion({"status": "error"})
|
|
assert result["status"] == "ignored"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_claims_flag_before_posting(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
# Claim-then-post: the dedup flag must be set before the reply is posted so a
|
|
# retried/concurrent webhook can't double-post the canned failure message.
|
|
client = _FakeClient(_slack_metadata())
|
|
monkeypatch.setattr(completion, "langgraph_client", lambda: client)
|
|
|
|
async def _reply(*_args: Any, **_kwargs: Any) -> bool:
|
|
assert client.threads.updates == [{"failure_reply_posted": True}]
|
|
return True
|
|
|
|
monkeypatch.setattr(completion, "post_slack_thread_reply", AsyncMock(side_effect=_reply))
|
|
|
|
result = await completion.handle_run_completion({"thread_id": "t1", "status": "error"})
|
|
assert result["status"] == "ok"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_does_not_post_when_claim_fails(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
client = _FakeClient(_slack_metadata())
|
|
client.threads.update = AsyncMock(side_effect=RuntimeError("boom"))
|
|
monkeypatch.setattr(completion, "langgraph_client", lambda: client)
|
|
reply = AsyncMock(return_value=True)
|
|
monkeypatch.setattr(completion, "post_slack_thread_reply", reply)
|
|
|
|
result = await completion.handle_run_completion({"thread_id": "t1", "status": "error"})
|
|
assert result["status"] == "error"
|
|
reply.assert_not_called()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_no_reply_channel_does_not_flag(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
client = _FakeClient({"source": "schedule"})
|
|
monkeypatch.setattr(completion, "langgraph_client", lambda: client)
|
|
|
|
result = await completion.handle_run_completion({"thread_id": "t1", "status": "error"})
|
|
|
|
assert result["status"] == "ignored"
|
|
assert client.threads.updates == []
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_interrupted_status_is_ignored(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
# Follow-ups use multitask_strategy="interrupt", so an interrupted run is a
|
|
# healthy hand-off, not a failure to report.
|
|
client = _FakeClient(_slack_metadata())
|
|
monkeypatch.setattr(completion, "langgraph_client", lambda: client)
|
|
reply = AsyncMock(return_value=True)
|
|
monkeypatch.setattr(completion, "post_slack_thread_reply", reply)
|
|
|
|
result = await completion.handle_run_completion({"thread_id": "t1", "status": "interrupted"})
|
|
|
|
assert result["status"] == "ignored"
|
|
reply.assert_not_called()
|
|
assert client.threads.updates == []
|
|
|
|
|
|
def test_verify_run_complete_token(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
# No secret configured: fail closed (reject everything).
|
|
monkeypatch.setattr(completion, "RUN_COMPLETE_WEBHOOK_SECRET", None)
|
|
assert completion.verify_run_complete_token(None) is False
|
|
assert completion.verify_run_complete_token("whatever") is False
|
|
|
|
# Secret configured: require an exact match.
|
|
monkeypatch.setattr(completion, "RUN_COMPLETE_WEBHOOK_SECRET", "s3cret")
|
|
assert completion.verify_run_complete_token("s3cret") is True
|
|
assert completion.verify_run_complete_token("wrong") is False
|
|
assert completion.verify_run_complete_token(None) is False
|