codna 0.2.23__tar.gz → 0.2.25__tar.gz

{codna-0.2.23 → codna-0.2.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.23
+Version: 0.2.25
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.23 → codna-0.2.25}/codna/__init__.py

@@ -5,4 +5,4 @@ This package is the `codna` CLI. Users never touch "algenta" directly — the en
 is an internal dependency reached over HTTP.
 """
 
-__version__ = "0.2.23"
+__version__ = "0.2.25"

{codna-0.2.23 → codna-0.2.25}/codna/webhook.py

@@ -116,8 +116,11 @@ def _fix_context_from_review_comment(pr: Mapping[str, Any], comment: Mapping[str
     if not isinstance(line, int):
         line = comment.get("original_line") if isinstance(comment.get("original_line"), int) else None
     path = comment.get("path")
+    commenter = (comment.get("user") or {}).get("login")
     return {
         "in_reply_to_id": in_reply_to,
+        "commenter": commenter if isinstance(commenter, str) and commenter else None,
+        "author_association": comment.get("author_association"),
         "path": path if isinstance(path, str) and path else None,
         "line": line,
         "head_sha": _safe_ref(head.get("sha")),
@@ -269,10 +272,13 @@ def classify_event(event: str, payload: Mapping[str, Any]) -> WebhookJob | None:
             if verb == "review":
                 return WebhookJob("review", repo, pr_number=number,
                                   installation_id=installation, reason="review_comment_codna_review")
-            if verb == "fix" and comment.get("author_association") in _FIX_WRITE_ASSOCIATIONS:
+            if verb == "fix":
                 # `@codna fix` reply to a Codna finding → route that finding into a verified fix PR.
-                # Gated to write-level commenters (above); the worker then fetches the parent finding
-                # + verifies Codna authored it before spending. An unprivileged `@codna fix` is ignored.
+                # Authorization happens in the WORKER against the repository's collaborator
+                # permission, not here: the payload's author_association is not reliable across
+                # repos -- GitHub sent CONTRIBUTOR for an org admin on thyn-ai/algenta-integrations
+                # (2026-09-17) while the REST API reported MEMBER for the same comment, and the gate
+                # that used to live here dropped the request without a trace.
                 ctx = _fix_context_from_review_comment(pr, comment)
                 if ctx is not None:
                     return WebhookJob("fix", repo, ref=ctx.get("head_sha"), pr_number=number,
@@ -582,6 +588,30 @@ def default_queue_path() -> str:
 
 
 # --- self-hostable server: verify + enqueue (thin ingress) ----------------------------
+def _log_delivery(event: str, payload: Mapping[str, Any], delivery_id: str | None, outcome: str,
+                  job: WebhookJob | None = None) -> None:
+    """One stderr JSON line per verified delivery: what arrived and what became of it.
+
+    Until now a delivery that classified as `ignored` or collapsed as a `duplicate` left no trace
+    anywhere -- on 2026-09-17 a `@codna fix` reply produced neither a job nor a log line and the
+    only way to tell "never delivered" from "delivered and dropped" was to guess. Same shape as the
+    worker's lines so one grep covers ingress and processing (`"service": "codna-webhook"`).
+    """
+    repo = (payload.get("repository") or {}).get("full_name")
+    line = {
+        "service": "codna-webhook",
+        "event": "delivery",
+        "github_event": event,
+        "action": payload.get("action"),
+        "delivery_id": delivery_id,
+        "repo": repo,
+        "outcome": outcome,
+    }
+    if job is not None:
+        line.update({"kind": job.kind, "reason": job.reason, "pr_number": job.pr_number})
+    print(json.dumps(line, sort_keys=True), file=sys.stderr, flush=True)
+
+
 class _Handler(BaseHTTPRequestHandler):
     server_version = "codna-webhook/2"
 
@@ -662,7 +692,9 @@ class _Handler(BaseHTTPRequestHandler):
             self._reply(400, {"error": "invalid_json"})
             return
         job = classify_event(event, payload)
+        delivery_header = self.headers.get("X-GitHub-Delivery")
         if job is None:
+            _log_delivery(event, payload, delivery_header, "ignored")
             self._reply(204, {"status": "ignored", "event": event})
             return
         # Idempotency key: prefer X-GitHub-Delivery; if absent (redelivery via a header-stripping
@@ -673,9 +705,11 @@ class _Handler(BaseHTTPRequestHandler):
         )
         queue = getattr(self.server, "queue", None)
         if queue is None:  # no durable queue (e.g. bare handler in a test) — accept without persisting
+            _log_delivery(event, payload, delivery_id, "accepted", job)
             self._reply(202, {"status": "accepted", "kind": job.kind, "repo": job.repo_full_name})
             return
         fresh = queue.enqueue(job, delivery_id=delivery_id)
+        _log_delivery(event, payload, delivery_id, "accepted" if fresh else "duplicate", job)
         self._reply(
             202 if fresh else 200,
             {"status": "accepted" if fresh else "duplicate", "kind": job.kind,

{codna-0.2.23 → codna-0.2.25}/codna/webhook_github.py

@@ -261,6 +261,31 @@ def find_open_pr_by_marker(repo_full_name: str, token: str, marker: str, *, max_
     return None
 
 
+def collaborator_permission(repo_full_name: str, token: str, username: str) -> str | None:
+    """The repository permission GitHub grants *username*: admin | maintain | write | triage | read |
+    none. None on any failure (the caller decides how to degrade). This is the authoritative answer
+    the webhook payload's author_association is not."""
+    try:
+        import httpx
+    except Exception:  # noqa: BLE001
+        return None
+    try:
+        resp = httpx.get(
+            f"{_API}/repos/{repo_full_name}/collaborators/{username}/permission",
+            headers={"Authorization": f"Bearer {token}", "Accept": "application/vnd.github+json"},
+            timeout=30.0, follow_redirects=True,
+        )
+    except Exception:  # noqa: BLE001
+        return None
+    if resp.status_code >= 300:
+        return None
+    try:
+        permission = (resp.json() or {}).get("permission")
+    except Exception:  # noqa: BLE001
+        return None
+    return str(permission) if permission else None
+
+
 def get_pull_review_comment(repo_full_name: str, token: str, comment_id: int) -> dict | None:
     """GET one PR review comment (the parent a user replied `@codna fix` to). None on any failure."""
     try:

{codna-0.2.23 → codna-0.2.25}/codna/webhook_worker.py

@@ -37,7 +37,7 @@ from typing import Any, Callable
 from . import webhook_github, webhook_metering
 from .admission_control import get_admitter
 from .agent_core_runtime import PROVIDER_RUNTIME_ENV_KEYS
-from .webhook import WebhookError, WebhookJob, codna_command, webhook_marker
+from .webhook import _FIX_WRITE_ASSOCIATIONS, WebhookError, WebhookJob, codna_command, webhook_marker
 from .webhook_queue import _MAX_ATTEMPTS, QueuedJob, WebhookQueue
 
 _JOB_TIMEOUT_S = int(os.environ.get("CODNA_WEBHOOK_JOB_TIMEOUT_S", "3600"))
@@ -311,6 +311,27 @@ def _terse_cli_failure(summary: str) -> str:
     return f"{rest.strip().rstrip('.')}{hint} [{code}]"
 
 
+_WRITE_PERMISSIONS = frozenset({"admin", "maintain", "write"})
+
+
+def _comment_fix_authorized(job: WebhookJob, token: str, github: Any) -> str | None:
+    """None when the commenter may request a fix; otherwise a short reason for the job summary."""
+    ctx = job.context or {}
+    login = ctx.get("commenter")
+    association = ctx.get("author_association")
+    lookup = getattr(github, "collaborator_permission", None)
+    permission = lookup(job.repo_full_name, token, login) if (callable(lookup) and login) else None
+    if permission is not None:
+        if permission in _WRITE_PERMISSIONS:
+            return None
+        return f"skipped: @{login} has {permission!r} access, `@codna fix` needs write"
+    # No authoritative answer: fall back to what the payload said. A context without any association
+    # at all predates this check (or is a synthetic job) and is allowed through unchanged.
+    if association is None or association in _FIX_WRITE_ASSOCIATIONS:
+        return None
+    return f"skipped: @{login or 'unknown'} is {association} and the permission lookup was unavailable"
+
+
 def _comment_fix_result_msg(job: WebhookJob, token: str, result: "JobResult", github: Any) -> str:
     """The reply Codna leaves on the finding thread after a comment-fix run."""
     if result.ok:
@@ -654,6 +675,18 @@ def process_job(
             if issue_text:
                 ctx["issue_text"] = issue_text
 
+    # Authorize a `@codna fix` reply BEFORE anything is spent or posted: the repository's collaborator
+    # permission for the commenter is authoritative; the payload's author_association only decides
+    # when that lookup itself is unavailable. Unauthorized requests get one polite reply and end as a
+    # non-failure (nothing to retry).
+    if reply_to and token:
+        verdict = _comment_fix_authorized(job, token, github)
+        if verdict is not None:
+            if qjob.attempts <= 1:
+                github.post_review_comment_reply(job.repo_full_name, token, job.pr_number, reply_to,
+                                                 "⚠️ `@codna fix` is limited to people with write access to this repository.")
+            return JobResult(True, verdict, retryable=False)
+
     # Idempotency: reuse a PR a prior attempt already opened. Checked BEFORE the ack so a redelivery
     # doesn't post a spurious "analyzing…" then "already opened". For a comment-fix only an OPEN PR
     # counts as a live duplicate — a closed prior fix PR must not block re-requesting a fresh one.

{codna-0.2.23 → codna-0.2.25}/codna.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.23
+Version: 0.2.25
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.23 → codna-0.2.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codna"
-version = "0.2.23"
+version = "0.2.25"
 description = "Local-first repo intelligence and agent fixing for Codna."
 readme = "README.md"
 requires-python = ">=3.10"

{codna-0.2.23 → codna-0.2.25}/tests/test_webhook.py

@@ -247,8 +247,12 @@ def test_classify_review_comment_fix_requires_write_level_commenter():
     # @codna fix SPENDS + PUSHES → only write-level commenters may trigger it.
     for assoc in ("OWNER", "MEMBER", "COLLABORATOR"):
         assert classify_event("pull_request_review_comment", _review_comment_payload(author_association=assoc)) is not None
+    # Since 2026-09-17 the payload association no longer decides: GitHub sent CONTRIBUTOR for an org
+    # admin, so every association classifies and the WORKER authorizes against the repository's
+    # collaborator permission. The association still travels in the context for the fallback.
     for assoc in ("CONTRIBUTOR", "FIRST_TIME_CONTRIBUTOR", "NONE", None):
-        assert classify_event("pull_request_review_comment", _review_comment_payload(author_association=assoc)) is None
+        job = classify_event("pull_request_review_comment", _review_comment_payload(author_association=assoc))
+        assert job is not None and job.context["author_association"] == assoc
 
 
 def test_classify_review_comment_fix_requires_a_reply_to_a_finding():
@@ -801,3 +805,40 @@ def test_fallback_pr_title_never_uses_model_prose():
         "codna: fix bug"
     )
     assert _fallback_pr_title(None, {}) == "codna: fix bug"
+
+
+
+def test_delivery_log_line_names_event_outcome_and_job(capsys):
+    import json as _json
+
+    from codna.webhook import WebhookJob, _log_delivery
+
+    payload = {"action": "created", "repository": {"full_name": "acme/app"}}
+    _log_delivery("pull_request_review_comment", payload, "d-1", "ignored")
+    job = WebhookJob("fix", "acme/app", ref="sha1", pr_number=7, reason="review_comment_codna_fix")
+    _log_delivery("pull_request_review_comment", payload, "d-2", "accepted", job)
+    lines = [_json.loads(x) for x in capsys.readouterr().err.splitlines() if x.startswith("{")]
+    assert [x["outcome"] for x in lines] == ["ignored", "accepted"]
+    assert lines[0]["github_event"] == "pull_request_review_comment" and lines[0]["repo"] == "acme/app"
+    assert lines[1]["kind"] == "fix" and lines[1]["pr_number"] == 7 and lines[1]["delivery_id"] == "d-2"
+    assert all(x["service"] == "codna-webhook" and x["event"] == "delivery" for x in lines)
+
+
+
+def test_fix_reply_is_classified_for_any_association_and_carries_the_commenter():
+    from codna.webhook import classify_event
+
+    payload = {
+        "action": "created",
+        "repository": {"full_name": "acme/app"},
+        "installation": {"id": 42},
+        "pull_request": {"number": 63, "draft": False,
+                         "head": {"sha": "a" * 40, "ref": "dependabot/x", "repo": {"full_name": "acme/app"}},
+                         "base": {"ref": "main", "repo": {"full_name": "acme/app"}}},
+        "comment": {"id": 2, "in_reply_to_id": 1, "body": "@codna fix", "author_association": "CONTRIBUTOR",
+                    "path": "python/pyproject.toml", "line": 69, "user": {"login": "angelatgithub"}},
+        "sender": {"login": "angelatgithub", "type": "User"},
+    }
+    job = classify_event("pull_request_review_comment", payload)
+    assert job is not None and job.kind == "fix" and job.pr_number == 63
+    assert job.context["commenter"] == "angelatgithub" and job.context["author_association"] == "CONTRIBUTOR"

{codna-0.2.23 → codna-0.2.25}/tests/test_webhook_worker.py

@@ -1361,3 +1361,54 @@ def test_terse_cli_failure_prefers_the_rejection_line_over_gits_generic_error_li
     terse = worker_module._terse_cli_failure(live)
     assert "refusing to allow a GitHub App" in terse and "failed to push some refs" not in terse
     assert terse.endswith("[git_command_failed]") and "/tmp/" not in terse
+
+
+
+# --- @codna fix authorization is the repository's collaborator permission, not the payload ------
+class _PermissionGitHub(_CommentFixGitHub):
+    def __init__(self, permission, **kw):
+        super().__init__(**kw)
+        self._permission = permission
+        self.permission_lookups = []
+
+    def collaborator_permission(self, repo, token, username):
+        self.permission_lookups.append(username)
+        return self._permission
+
+
+def _contributor_qjob(**over):
+    return _comment_fix_qjob(commenter="angelatgithub", author_association="CONTRIBUTOR", **over)
+
+
+def test_contributor_with_write_permission_gets_the_fix():
+    gh = _PermissionGitHub("admin", parent_body=_codna_finding_comment_body())
+    ran = []
+    result = process_job(_contributor_qjob(), app_id="APP", private_key="p", github=gh,
+                         runner=lambda job, **kw: ran.append(1) or JobResult(True, "opened"),
+                         resolve_engine_key=lambda iid: "org-key")
+    assert result.ok and ran and gh.permission_lookups == ["angelatgithub"]
+    assert any("On it" in b for (_p, _r, b) in gh.replies)
+
+
+def test_read_only_commenter_is_refused_before_any_spend():
+    gh = _PermissionGitHub("read", parent_body=_codna_finding_comment_body())
+    ran = []
+    result = process_job(_contributor_qjob(), app_id="APP", private_key="p", github=gh,
+                         runner=lambda job, **kw: ran.append(1) or JobResult(True, "opened"),
+                         resolve_engine_key=lambda iid: "org-key")
+    assert result.ok and result.retryable is False and "needs write" in result.summary
+    assert not ran
+    bodies = [b for (_p, _r, b) in gh.replies]
+    assert len(bodies) == 1 and "write access" in bodies[0] and "On it" not in bodies[0]
+    assert not any(c[0] == "create_check" for c in gh.calls)
+
+
+def test_permission_lookup_failure_falls_back_to_the_payload_association():
+    refused = process_job(_contributor_qjob(), app_id="APP", private_key="p",
+                          github=_PermissionGitHub(None, parent_body=_codna_finding_comment_body()),
+                          runner=lambda job, **kw: JobResult(True, "opened"), resolve_engine_key=lambda iid: "org-key")
+    assert "permission lookup was unavailable" in refused.summary
+    allowed = process_job(_comment_fix_qjob(commenter="angelatgithub", author_association="MEMBER"), app_id="APP",
+                          private_key="p", github=_PermissionGitHub(None, parent_body=_codna_finding_comment_body()),
+                          runner=lambda job, **kw: JobResult(True, "opened"), resolve_engine_key=lambda iid: "org-key")
+    assert allowed.ok and allowed.summary == "opened"