codna 0.2.14__tar.gz → 0.2.16__tar.gz

{codna-0.2.14 → codna-0.2.16}/PKG-INFO

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

{codna-0.2.14 → codna-0.2.16}/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.14"
+__version__ = "0.2.16"

{codna-0.2.14 → codna-0.2.16}/codna/agent-core/run-server.bundle.mjs

@@ -110643,7 +110643,7 @@ var init_bowser = __esm(() => {
 
 // agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client/index.js
 var require_client2 = __commonJS((exports) => {
-  var __dirname = "/Users/angel/Developer/actions-runner/_work/codna/codna/agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
+  var __dirname = "/Users/angel/actions-runner-mac-3/_work/codna/codna/agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
   var retry2 = require_retry2();
   var protocols = require_protocols();
   var lambdaInvokeStore = require_invoke_store();

{codna-0.2.14 → codna-0.2.16}/codna/agent_core_runtime.py

@@ -421,12 +421,21 @@ def _stop_owned_sidecar(
         return
     if _request_owned_sidecar_shutdown(config):
         return
-    attempted_pids = [
-        pid
-        for pid in (listener.parent_pid, listener.pid)
-        if pid is not None
-    ]
-    attempted_pids = list(dict.fromkeys(attempted_pids))
+    # ONLY the verified listener PID -- never listener.parent_pid. `spawn_detached_process` execs
+    # the sidecar command directly (no wrapper process), so while the ORIGINAL caller that started
+    # it is still alive, lsof's reported "parent" IS that caller, not an orphaned launcher to clean
+    # up. On a single machine running several `codna fix` invocations at once (concurrent webhook
+    # jobs, or just two terminals), that caller is frequently a DIFFERENT process doing DIFFERENT,
+    # unrelated, still-useful work — and this used to SIGTERM-then-SIGKILL it, not just the
+    # sidecar. Confirmed live: two concurrent fixes with different provider keys triggered
+    # state_fingerprint_or_provider_mismatch, and the "cleanup" killed the peer's own `codna fix`
+    # process before its sidecar. `listener.pid` is independently verified as the thing actually
+    # LISTENING on the port (that's what put it in `listener` at all); nothing here is verified
+    # about parent_pid beyond "lsof reported some number as PPID at one instant." A leftover
+    # parent that genuinely has nothing left to do exits on its own once its child (the sidecar)
+    # is gone; a manual `codna doctor` hint can still suggest killing it explicitly (see
+    # _manual_stop_command) — that's a human decision, never an automated one.
+    attempted_pids = [listener.pid]
     try:
         for pid in attempted_pids:
             terminate_pid(

{codna-0.2.14 → codna-0.2.16}/codna/webhook_worker.py

@@ -21,6 +21,7 @@ fakes and no network.
 from __future__ import annotations
 
 import os
+import socket
 import subprocess
 import tempfile
 import threading
@@ -28,6 +29,7 @@ import time
 import sys
 import json
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Any, Callable
 
 from . import webhook_github, webhook_metering
@@ -129,15 +131,64 @@ def _comment_fix_result_msg(job: WebhookJob, token: str, result: "JobResult", gi
             "test + risk gate, so nothing was pushed (fail-closed). You can apply the fix manually.")
 
 
+def _free_port_pair() -> tuple[int, int] | None:
+    """Two ADJACENT free ports (engine, engine+1 for the sidecar -- runtime_config.
+    local_runtime_urls' own contract) via OS-assigned ephemeral ports, not a hash of job
+    identity: a hash risks two DIFFERENT jobs deriving the SAME port by coincidence, which is
+    exactly the collision this exists to eliminate, not reintroduce more quietly. Binding port 0
+    and reading back what the kernel assigned, then releasing it immediately, is the standard way
+    to get a free port without a race against every other consumer of "free port" on the box --
+    it isn't airtight (something else could grab it in the gap before the sidecar itself binds),
+    but that residual is the same one every ephemeral-port scheme accepts, not a new one.
+    Returns None (never raises) if binding just doesn't work; the caller falls back to sharing
+    the default ports rather than failing the job over a nice-to-have."""
+    for _attempt in range(5):
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe:
+                probe.bind(("127.0.0.1", 0))
+                base = probe.getsockname()[1]
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe:
+                probe.bind(("127.0.0.1", base + 1))
+        except OSError:
+            continue  # base+1 was taken; try another base rather than fail the job over this
+        return base, base + 1
+    return None
+
+
+def _isolated_runtime_env(tmp: str) -> dict[str, str]:
+    """CODNA_RUNTIME_ROOT + CODNA_PORT_BASE unique to THIS job, so concurrent jobs never share a
+    sidecar in the first place -- the root cause of the P0 this closes: two jobs sharing one
+    sidecar by design (same runtime_config_hash) tore each other's down mid-turn whenever their
+    provider keys differed, which is the routine case on a multi-tenant webhook, not an edge case.
+    CODNA_RUNTIME_ROOT nests inside the job's own scratch dir (`tmp`, already a fresh
+    TemporaryDirectory per job), so it's already guaranteed unique and is cleaned up for free when
+    that directory is removed -- no separate bookkeeping, nothing to leak across jobs.
+    """
+    env = {"CODNA_RUNTIME_ROOT": str(Path(tmp) / ".codna-runtime")}
+    ports = _free_port_pair()
+    if ports is not None:
+        env["CODNA_PORT_BASE"] = str(ports[0])
+    # No free-port fallback: CODNA_RUNTIME_ROOT alone still isolates each job's runtime STATE
+    # (they no longer read/write the same local-stack.json), even if two jobs end up sharing the
+    # default ports on a probe failure -- degraded, not broken, and never worth failing the job.
+    return env
+
+
 def _job_env(
     token: str | None, engine_key: str | None,
     provider: str | None = None, provider_key: str | None = None,
+    *, tmp: str | None = None,
 ) -> dict[str, str]:
     """Minimal allowlisted env + the scoped GitHub token, per-org Codna key, and (when the
     linked org has configured one) their own BYOK provider key — set consistently regardless of
     which of Anthropic/OpenAI/Google the org picked, so the local agent-core sidecar always finds
     a usable key instead of only ever checking for Anthropic's."""
     env = {k: v for k, v in os.environ.items() if k in _ENV_ALLOWLIST}
+    if tmp is not None:
+        # Job-specific isolation OVERRIDES whatever the host process's own env carries for these
+        # two keys -- inheriting the host's shared values here would silently defeat the whole
+        # point (every job would still resolve to the one shared runtime this exists to avoid).
+        env.update(_isolated_runtime_env(tmp))
     if token:
         env["GITHUB_TOKEN"] = token
     if engine_key:
@@ -195,7 +246,7 @@ def run_codna_job(job: WebhookJob, *, token: str | None, engine_key: str | None,
         argv[0] = codna_bin
         try:
             proc = subprocess.run(
-                argv, env=_job_env(token, engine_key, provider, provider_key), cwd=tmp,
+                argv, env=_job_env(token, engine_key, provider, provider_key, tmp=tmp), cwd=tmp,
                 capture_output=True, text=True, timeout=_JOB_TIMEOUT_S,
                 start_new_session=True,  # own process group: isolated from signals, terminable as a unit
             )

{codna-0.2.14 → codna-0.2.16}/codna.egg-info/PKG-INFO

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

{codna-0.2.14 → codna-0.2.16}/pyproject.toml

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

{codna-0.2.14 → codna-0.2.16}/tests/test_agent_core_runtime.py

@@ -264,7 +264,10 @@ def test_agent_core_restarts_owned_runtime_when_fingerprint_is_stale(tmp_path, m
 
     assert endpoint.runtime_id == "runtime-2"
     assert endpoint.pid == 456
-    assert terminated == [456, 123]
+    # ONLY the verified listener (123) is auto-killed -- never the reported parent_pid (456), which
+    # on a machine running several codna invocations at once could be a live, unrelated process
+    # (see test_stop_owned_sidecar_never_auto_kills_the_reported_parent_pid for the direct case).
+    assert terminated == [123]
     assert starts == [True]
 
 
@@ -508,6 +511,57 @@ def test_agent_core_inspection_reports_stale_recovery_for_missing_state(
     }
 
 
+def test_provider_mismatch_never_kills_the_reported_parent_pid(tmp_path, monkeypatch) -> None:
+    """The actual P0: two concurrent `codna fix` processes share a sidecar by design (same
+    runtime_config_hash), and org B's own BYOK provider key differs from org A's -- a completely
+    routine, EXPECTED situation on a shared webhook worker, not a corruption. That must tear down
+    the sidecar (123) to restart it with B's env, but must NEVER touch parent_pid (456) -- on a
+    machine running concurrent fixes, "456" is frequently org A's own still-running `codna fix`
+    process, not an orphaned launcher. Reproduced directly against ensure_agent_core_running with
+    no mocked shortcuts around _stop_owned_sidecar itself.
+    """
+    monkeypatch.setenv("CODNA_RUNTIME_ROOT", str(tmp_path / ".codna"))
+    config = resolve_runtime_config()
+    state = {
+        "runtime_id": "runtime-org-a",
+        "codna_cli_version": config.codna_cli_version,
+        "sidecar_build_id": config.sidecar_build_id,
+        "runtime_config_hash": config.runtime_config_hash,
+        # Deliberately NO provider_env_hash -- org A's fix set this from ITS OWN provider key, and
+        # the absence here (rather than a matching one) is what drives both
+        # _state_provider_env_matches AND the legacy-hash fallback to False, landing on the exact
+        # branch that calls _stop_owned_sidecar(reason="state_fingerprint_or_provider_mismatch").
+    }
+    terminated: list[int] = []
+
+    monkeypatch.setattr(agent_core_runtime, "runtime_lock", _unlocked)
+    # 456 stands in for org A's OWN live `codna fix` process -- the one that spawned this sidecar
+    # and is still running it, exactly as `lsof -R` reports on a real machine while that process
+    # (start_new_session=True) hasn't exited yet.
+    monkeypatch.setattr(agent_core_runtime, "_single_listener", lambda port: _listener(port, parent_pid=456))
+    monkeypatch.setattr(agent_core_runtime, "_load_state", lambda _config: state)
+    monkeypatch.setattr(agent_core_runtime, "_state_owns_listener", lambda _state, _listener: True)
+    monkeypatch.setattr(agent_core_runtime, "_state_provider_env_matches", lambda _state, _keys: False)
+    monkeypatch.setattr(
+        agent_core_runtime,
+        "_service_is_codna_sidecar",
+        lambda active_config: _healthy_probe("runtime-org-a", build_id=active_config.sidecar_build_id),
+    )
+    monkeypatch.setattr(agent_core_runtime, "terminate_pid", lambda pid, **_kwargs: terminated.append(pid))
+    monkeypatch.setattr(agent_core_runtime, "_request_owned_sidecar_shutdown", lambda _config: False)
+    monkeypatch.setattr(
+        agent_core_runtime, "_start_sidecar",
+        lambda *_a, **_k: AgentCoreEndpoint(url="http://127.0.0.1:28601", port=28601,
+                                            runtime_id="runtime-org-b", pid=789),
+    )
+
+    endpoint = ensure_agent_core_running()
+
+    assert endpoint.runtime_id == "runtime-org-b"      # org B correctly got its own fresh sidecar
+    assert terminated == [123]                          # ONLY the verified sidecar listener
+    assert 456 not in terminated, "org A's own live process must never be auto-killed"
+
+
 def test_agent_core_stop_health_proven_stale_sidecar_stops_parent_then_child(
     tmp_path,
     monkeypatch,
@@ -538,7 +592,9 @@ def test_agent_core_stop_health_proven_stale_sidecar_stops_parent_then_child(
     assert payload["status"] == "stopped"
     assert payload["listener"]["pid"] == 123
     assert payload["listener"]["parent_pid"] == 456
-    assert stopped == [456, 123]
+    # parent_pid (456) is reported in the payload for diagnostics, but never auto-killed -- only
+    # the verified listener (123) is.
+    assert stopped == [123]
 
 
 def test_agent_core_stop_falls_back_without_runtime_lock_for_health_proven_sidecar(
@@ -579,7 +635,7 @@ def test_agent_core_stop_falls_back_without_runtime_lock_for_health_proven_sidec
     assert payload["lock_acquired"] is False
     assert payload["listener"]["pid"] == 123
     assert payload["listener"]["parent_pid"] == 456
-    assert stopped == [456, 123]
+    assert stopped == [123]
 
 
 

{codna-0.2.14 → codna-0.2.16}/tests/test_webhook_feedback_dispatch.py

@@ -156,3 +156,87 @@ def test_comment_fix_without_head_ref_still_raises_fix_requires_head_ref():
     with pytest.raises(WebhookError) as exc:
         codna_command(job)
     assert exc.value.code == "fix_requires_head_ref"
+
+
+# ── E2E signed ingress: full HTTP → classify → route path ───────────────────────────────────────
+def test_signed_ingress_routes_feedback_codna_fix_label_to_thyn_ai_codna(monkeypatch, tmp_path):
+    """E2E: a signed `issues.labeled` delivery on thyn-ai/feedback with `codna-fix` and
+    `product:codna` must be accepted (202), enqueued, and the queued job must target
+    thyn-ai/codna — not the feedback repo itself.
+
+    This covers the real live scenario described in the Phase 3 cross-repo dispatch verification
+    report: label a report on the public intake repo, the webhook routes it to thyn-ai/codna.
+    """
+    import hashlib
+    import hmac
+    import json
+    import threading
+    import time
+    import urllib.request
+    from http.server import ThreadingHTTPServer
+
+    from codna.webhook import FIX_LABEL, _Handler
+    from codna.webhook_queue import WebhookQueue
+    from codna.webhook_worker import JobResult, WorkerPool
+
+    _feedback_env(monkeypatch)
+    secret = "e2e-test-secret"
+    monkeypatch.setenv("CODNA_GITHUB_WEBHOOK_SECRET", secret)
+
+    queue = WebhookQueue(tmp_path / "q.db")
+    httpd = ThreadingHTTPServer(("127.0.0.1", 0), _Handler)
+    httpd.queue = queue  # type: ignore[attr-defined]
+    port = httpd.server_address[1]
+    threading.Thread(target=httpd.serve_forever, daemon=True).start()
+
+    payload = json.dumps({
+        "action": "labeled",
+        "repository": {"full_name": "thyn-ai/feedback"},
+        "installation": {"id": 7},
+        "label": {"name": FIX_LABEL},
+        "issue": {"number": 42, "labels": [{"name": "needs-triage"}, {"name": "product:codna"}]},
+    }).encode()
+    sig = "sha256=" + hmac.new(secret.encode(), payload, hashlib.sha256).hexdigest()
+
+    try:
+        req = urllib.request.Request(
+            f"http://127.0.0.1:{port}/webhooks/github", data=payload, method="POST",
+            headers={"X-GitHub-Event": "issues", "X-Hub-Signature-256": sig,
+                     "X-GitHub-Delivery": "e2e-feedback-codna-1",
+                     "Content-Type": "application/json"},
+        )
+        resp = urllib.request.urlopen(req, timeout=5)
+        body = json.loads(resp.read())
+
+        assert resp.status == 202
+        assert body["status"] == "accepted"
+        assert body["kind"] == "fix"
+        assert body["repo"] == "thyn-ai/codna"   # routed to the product repo, NOT feedback
+        assert body["reason"] == "feedback_routed_fix"
+        assert queue.counts().get("queued") == 1
+
+        # Drain the queue and confirm the job targets thyn-ai/codna with the right context.
+        processed_jobs = []
+        pool = WorkerPool(
+            queue, concurrency=1, poll_interval=0.02,
+            process=lambda qj: (processed_jobs.append(qj.job) or JobResult(True, "ok")),
+        )
+        pool.start()
+        deadline = time.monotonic() + 10
+        while time.monotonic() < deadline and queue.counts().get("done", 0) < 1:
+            time.sleep(0.05)
+        pool.stop()
+
+        assert len(processed_jobs) == 1
+        job = processed_jobs[0]
+        assert job.kind == "fix"
+        assert job.repo_full_name == "thyn-ai/codna"
+        assert job.issue_number is None                      # issue lives on the feedback repo
+        assert (job.context or {}).get("feedback_repo") == "thyn-ai/feedback"
+        assert (job.context or {}).get("feedback_issue") == 42
+        assert (job.context or {}).get("product") == "codna"
+        assert "routing_error" not in (job.context or {})
+        assert queue.counts().get("done") == 1
+    finally:
+        httpd.shutdown()
+        httpd.server_close()

{codna-0.2.14 → codna-0.2.16}/tests/test_webhook_worker.py

@@ -16,6 +16,128 @@ def _qjob(kind="fix", ref="sha1", installation_id=42):
                      job=WebhookJob(kind, "acme/app", ref=ref, installation_id=installation_id, reason="test"))
 
 
+# --- env: per-job runtime isolation (the P0 fix -- concurrent jobs never share a sidecar) -----
+def test_free_port_pair_returns_two_adjacent_ports():
+    pair = worker_module._free_port_pair()
+    assert pair is not None
+    base, sidecar = pair
+    assert sidecar == base + 1
+
+
+def test_free_port_pair_returns_the_exact_ports_it_actually_probed(monkeypatch):
+    """REGRESSION-shaped: the returned tuple must be the SAME ports that were bind-tested, not
+    merely two numbers one-apart -- a probe of the wrong port (e.g. base+2 while still returning
+    base+1) would pass a check that only looks at the return value's arithmetic, while actually
+    verifying nothing about whether the port it hands back is free."""
+    bound: list[int] = []
+    real_socket = worker_module.socket.socket
+
+    class _RecordingSocket:
+        def __init__(self, *a, **k):
+            self._s = real_socket(*a, **k)
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc):
+            self._s.close()
+            return False
+
+        def bind(self, addr):
+            bound.append(addr[1])
+            self._s.bind(addr)
+
+        def getsockname(self):
+            return self._s.getsockname()
+
+    monkeypatch.setattr(worker_module.socket, "socket", lambda *a, **k: _RecordingSocket(*a, **k))
+    pair = worker_module._free_port_pair()
+    assert pair is not None
+    assert bound == [0, pair[0] + 1]  # first bind is ephemeral (port 0); second checks base+1 EXACTLY
+
+
+def test_free_port_pair_does_not_repeat_across_calls():
+    """Not a hash of job identity -- if it were, two different jobs could derive the SAME port by
+    coincidence, reintroducing the exact class of collision this exists to eliminate."""
+    seen = {worker_module._free_port_pair() for _ in range(5)}
+    assert len(seen) == 5
+
+
+def test_isolated_runtime_env_nests_inside_the_jobs_own_scratch_dir(tmp_path):
+    env = worker_module._isolated_runtime_env(str(tmp_path))
+    assert env["CODNA_RUNTIME_ROOT"] == str(tmp_path / ".codna-runtime")
+    assert "CODNA_PORT_BASE" in env
+
+
+def test_isolated_runtime_env_degrades_without_a_port_when_probing_fails(monkeypatch, tmp_path):
+    """A probe failure must shrink the isolation, never fail the job -- CODNA_RUNTIME_ROOT alone
+    still keeps two jobs' runtime STATE apart even if they end up sharing the default ports."""
+    monkeypatch.setattr(worker_module, "_free_port_pair", lambda: None)
+    env = worker_module._isolated_runtime_env(str(tmp_path))
+    assert "CODNA_RUNTIME_ROOT" in env
+    assert "CODNA_PORT_BASE" not in env
+
+
+def test_job_env_without_tmp_is_unaffected_by_isolation(monkeypatch):
+    """Back-compat: callers that don't pass tmp= (existing tests, any future direct caller) get
+    exactly the old behavior -- isolation is opt-in via the keyword, not a silent default change
+    that could surprise a caller who isn't expecting CODNA_RUNTIME_ROOT/CODNA_PORT_BASE to appear.
+
+    Explicitly clears both from the ambient env first: whether they happen to be set in the
+    environment this suite runs in is not this test's concern -- an inherited value passing
+    through the allowlist (pre-existing behavior) is not the same claim as "this call injects
+    nothing new," which is the one actually being tested here.
+    """
+    monkeypatch.delenv("CODNA_RUNTIME_ROOT", raising=False)
+    monkeypatch.delenv("CODNA_PORT_BASE", raising=False)
+    env = worker_module._job_env("tok", "ekey")
+    assert "CODNA_RUNTIME_ROOT" not in env
+    assert "CODNA_PORT_BASE" not in env
+
+
+def test_job_env_with_tmp_overrides_the_hosts_own_shared_runtime_root(monkeypatch, tmp_path):
+    """REGRESSION-shaped: the whole point is defeated if a job silently inherits the WEBHOOK
+    PROCESS's own CODNA_RUNTIME_ROOT instead of getting its own -- that's the exact shared state
+    that let two jobs discover and tear down each other's sidecar."""
+    monkeypatch.setenv("CODNA_RUNTIME_ROOT", "/shared/host/runtime")
+    env = worker_module._job_env("tok", "ekey", tmp=str(tmp_path))
+    assert env["CODNA_RUNTIME_ROOT"] != "/shared/host/runtime"
+    assert env["CODNA_RUNTIME_ROOT"].startswith(str(tmp_path))
+
+
+def test_job_env_with_tmp_gives_two_concurrent_jobs_different_runtime_roots_and_ports(tmp_path):
+    a = worker_module._job_env("tok-a", "ekey-a", tmp=str(tmp_path / "job-a"))
+    b = worker_module._job_env("tok-b", "ekey-b", tmp=str(tmp_path / "job-b"))
+    assert a["CODNA_RUNTIME_ROOT"] != b["CODNA_RUNTIME_ROOT"]
+    assert a["CODNA_PORT_BASE"] != b["CODNA_PORT_BASE"]
+
+
+def test_run_codna_job_passes_its_own_scratch_dir_to_job_env(monkeypatch):
+    """run_codna_job must actually WIRE tmp through, not just leave the isolation code unreachable
+    dead weight -- confirms the argument that reaches subprocess.run's env came from _job_env(tmp=...)."""
+    captured = {}
+
+    def _fake_job_env(*args, **kwargs):
+        captured["tmp"] = kwargs.get("tmp")
+        return {}
+
+    def _fake_run(argv, **kwargs):
+        class _P:
+            returncode = 0
+            stdout = ""
+            stderr = ""
+        return _P()
+
+    monkeypatch.setattr(worker_module, "_job_env", _fake_job_env)
+    monkeypatch.setattr("subprocess.run", _fake_run)
+    job = WebhookJob("fix", "acme/app", ref="sha1")
+    run_codna_job(job, token="t", engine_key="k")
+
+    assert captured["tmp"] is not None
+    import tempfile
+    assert captured["tmp"].startswith(tempfile.gettempdir()) or "codna-webhook-job-" in captured["tmp"]
+
+
 # --- env: keyless (Codna credential injected, no raw provider key, no host secrets) ----------
 def test_job_env_blocks_arbitrary_and_app_secrets_and_raw_provider_keys(monkeypatch):
     for k in ("AWS_SECRET_ACCESS_KEY", "GH_PAT", "STRIPE_SECRET_KEY", "SUPABASE_TOKEN", "PGPASSWORD",