code-coordinator 0.5.46__py3-none-any.whl

coord/network.py

@@ -0,0 +1,269 @@
+"""Network health checks for agent servers over Tailscale (plain HTTP).
+
+Tailscale's MagicDNS resolves hostnames and the tailnet encrypts the
+connection, so we use plain HTTP on the agent port. This module classifies
+connection failures so the CLI can give actionable diagnostics rather than
+a generic "offline".
+"""
+
+from __future__ import annotations
+
+import socket
+import time
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from typing import Iterable
+
+import httpx
+
+from coord.models import Machine
+
+AGENT_PORT = 7433
+DEFAULT_TIMEOUT = 3.0
+
+# Status categories — keep these stable; downstream code may key off them.
+ONLINE = "online"
+OFFLINE = "offline"
+TIMEOUT = "timeout"
+DNS_ERROR = "dns_error"
+HTTP_ERROR = "http_error"
+RATE_LIMITED = "rate_limited"
+UNKNOWN = "unknown"
+
+
+@dataclass
+class MachineStatus:
+    machine: Machine
+    state: str
+    reason: str = ""
+    latency_ms: float | None = None
+    health: dict | None = None
+
+    @property
+    def is_online(self) -> bool:
+        return self.state == ONLINE
+
+
+def classify_error(exc: Exception) -> tuple[str, str]:
+    """Map an httpx/network exception to a (state, reason) pair."""
+    if isinstance(exc, httpx.ConnectTimeout) or isinstance(exc, httpx.ReadTimeout):
+        return TIMEOUT, "timed out"
+    if isinstance(exc, httpx.ConnectError):
+        msg = str(exc).lower()
+        if "name or service not known" in msg or "nodename nor servname" in msg or "getaddrinfo" in msg:
+            return DNS_ERROR, "hostname not resolvable (Tailscale up?)"
+        if "connection refused" in msg:
+            return OFFLINE, "connection refused (agent not running?)"
+        return OFFLINE, f"connection failed ({exc})"
+    if isinstance(exc, socket.gaierror):
+        return DNS_ERROR, "hostname not resolvable (Tailscale up?)"
+    if isinstance(exc, httpx.HTTPStatusError) and exc.response.status_code == 429:
+        return RATE_LIMITED, "rate limited (429 Too Many Requests)"
+    if isinstance(exc, httpx.HTTPError):
+        return HTTP_ERROR, f"http error: {exc}"
+    return UNKNOWN, f"{type(exc).__name__}: {exc}"
+
+
+def is_retryable(state: str) -> bool:
+    """Whether a classified error state should trigger a retry."""
+    return state in (TIMEOUT, RATE_LIMITED, HTTP_ERROR)
+
+
+def check_machine(machine: Machine, timeout: float = DEFAULT_TIMEOUT) -> MachineStatus:
+    """Ping `machine`'s /health endpoint and classify the result."""
+    url = f"http://{machine.host}:{AGENT_PORT}/health"
+    start = time.perf_counter()
+    try:
+        resp = httpx.get(url, timeout=timeout)
+    except Exception as e:  # noqa: BLE001 — we classify all network errors
+        state, reason = classify_error(e)
+        return MachineStatus(machine=machine, state=state, reason=reason)
+
+    latency_ms = (time.perf_counter() - start) * 1000.0
+    if resp.status_code != 200:
+        return MachineStatus(
+            machine=machine,
+            state=HTTP_ERROR,
+            reason=f"HTTP {resp.status_code}",
+            latency_ms=latency_ms,
+        )
+    try:
+        health = resp.json()
+    except ValueError:
+        return MachineStatus(
+            machine=machine,
+            state=HTTP_ERROR,
+            reason="invalid JSON from /health",
+            latency_ms=latency_ms,
+        )
+    return MachineStatus(
+        machine=machine,
+        state=ONLINE,
+        reason="",
+        latency_ms=latency_ms,
+        health=health,
+    )
+
+
+def check_all(
+    machines: Iterable[Machine],
+    timeout: float = DEFAULT_TIMEOUT,
+    max_workers: int | None = None,
+) -> list[MachineStatus]:
+    """Health-check every machine concurrently. Preserves input order."""
+    machines = list(machines)
+    if not machines:
+        return []
+    workers = max_workers or min(8, len(machines))
+    with ThreadPoolExecutor(max_workers=workers) as pool:
+        return list(pool.map(lambda m: check_machine(m, timeout=timeout), machines))
+
+
+@dataclass
+class StatusResult:
+    """Result of fetching /status from an agent.
+
+    On success, ``data`` holds the parsed response and ``error`` is None.
+    On failure, ``data`` is None and ``error`` describes what went wrong.
+    """
+
+    data: dict | None = None
+    error: str | None = None
+
+    @property
+    def ok(self) -> bool:
+        return self.data is not None
+
+
+def fetch_status(machine: Machine, timeout: float = DEFAULT_TIMEOUT) -> StatusResult:
+    """GET /status from a machine. Returns a StatusResult (never None)."""
+    try:
+        resp = httpx.get(
+            f"http://{machine.host}:{AGENT_PORT}/status", timeout=timeout
+        )
+        resp.raise_for_status()
+        return StatusResult(data=resp.json())
+    except httpx.HTTPStatusError as exc:
+        return StatusResult(error=f"HTTP {exc.response.status_code}")
+    except (httpx.ConnectTimeout, httpx.ReadTimeout):
+        return StatusResult(error="timeout")
+    except httpx.ConnectError as exc:
+        return StatusResult(error=f"connection error: {exc}")
+    except (httpx.HTTPError, ValueError) as exc:
+        return StatusResult(error=str(exc))
+
+
+def fetch_repos(machine: Machine, timeout: float = DEFAULT_TIMEOUT) -> dict | None:
+    """GET /repos. Returns None on network error (per-repo errors come back inside the dict)."""
+    try:
+        resp = httpx.get(
+            f"http://{machine.host}:{AGENT_PORT}/repos", timeout=timeout
+        )
+        resp.raise_for_status()
+        return resp.json()
+    except (httpx.HTTPError, ValueError):
+        return None
+
+
+def fetch_log(
+    machine: Machine,
+    assignment_id: str,
+    *,
+    since: int = 0,
+    timeout: float = DEFAULT_TIMEOUT,
+) -> tuple[int, bytes]:
+    """GET /logs/{id} from a machine. Returns (status_code, body)."""
+    url = f"http://{machine.host}:{AGENT_PORT}/logs/{assignment_id}"
+    params = {"since": since} if since else None
+    resp = httpx.get(url, params=params, timeout=timeout)
+    return resp.status_code, resp.content
+
+
+def inject_message(
+    machine: Machine,
+    assignment_id: str,
+    text: str,
+    *,
+    timeout: float = DEFAULT_TIMEOUT,
+) -> tuple[int, dict]:
+    """POST /inject/{id} to send `text` as a new user message to a running
+    worker.  Returns (status_code, response_body_dict).  Returned status:
+    202 on delivery, 404 unknown assignment, 409 not running, 410 stdin
+    closed, 400 bad body.
+    """
+    url = f"http://{machine.host}:{AGENT_PORT}/inject/{assignment_id}"
+    resp = httpx.post(url, json={"text": text}, timeout=timeout)
+    try:
+        body = resp.json()
+    except Exception:
+        body = {"error": "non-json response", "raw": resp.text[:200]}
+    return resp.status_code, body
+
+
+def clean_worktrees(
+    machine: Machine,
+    *,
+    recent_secs: float = 300.0,
+    protect: list[str] | None = None,
+    timeout: float = 30.0,
+) -> dict:
+    """POST /worktree-clean to `machine` (#1220).
+
+    Same endpoint the manual ``coord agent clean-worktrees`` CLI hits — this
+    is the helper a fleet-wide *automatic* sweep (``coord.serve_app``'s tick
+    loop) calls per machine.  Never raises: any network/HTTP/decode failure
+    is folded into the returned dict's ``error`` field (``ok=False``) so one
+    unreachable machine can't abort a sweep across the rest of the fleet.
+
+    #1295: an optional *protect* list of assignment IDs the coordinator
+    knows are still live (interactive sessions, dispatched-but-not-yet-
+    finished work) is forwarded to the agent so those worktrees are kept
+    even when the agent's own record has been lost (agent restart, DB
+    reload race).  A None / empty *protect* is omitted from the request
+    body so an older agent that doesn't know about the field sees the
+    same wire shape as before.
+
+    Returns ``{"ok": bool, "cleaned": int, "kept": int, "bytes_freed": int,
+    "cargo_cache_bytes": int, "cargo_caches_evicted": int,
+    "error": str | None}``.  The ``cargo_*`` fields (#1402) report the shared
+    cargo target cache's size after the agent's GC and how many per-repo
+    caches it evicted; they are 0 against an agent too old to report them.
+    """
+    url = f"http://{machine.host}:{AGENT_PORT}/worktree-clean"
+    payload: dict[str, object] = {"recent_secs": recent_secs}
+    if protect:
+        payload["protect"] = list(protect)
+    try:
+        resp = httpx.post(url, json=payload, timeout=timeout)
+    except Exception as e:  # noqa: BLE001 — classify uniformly, never propagate
+        _, reason = classify_error(e)
+        return {"ok": False, "cleaned": 0, "kept": 0, "bytes_freed": 0, "error": reason}
+    if resp.status_code != 200:
+        return {
+            "ok": False,
+            "cleaned": 0,
+            "kept": 0,
+            "bytes_freed": 0,
+            "error": f"HTTP {resp.status_code}",
+        }
+    try:
+        data = resp.json()
+    except ValueError:
+        return {
+            "ok": False,
+            "cleaned": 0,
+            "kept": 0,
+            "bytes_freed": 0,
+            "error": "invalid JSON from /worktree-clean",
+        }
+    return {
+        "ok": True,
+        "cleaned": data.get("cleaned", 0),
+        "kept": data.get("kept", 0),
+        "bytes_freed": data.get("bytes_freed", 0),
+        # #1402: shared cargo-cache GC counters.  ``.get`` defaults keep an
+        # older agent (which doesn't report them) on the same wire shape.
+        "cargo_cache_bytes": data.get("cargo_cache_bytes", 0),
+        "cargo_caches_evicted": data.get("cargo_caches_evicted", 0),
+        "error": None,
+    }

coord/new_issue_chat.py

@@ -0,0 +1,229 @@
+"""#316: dispatch a `type="new-issue-chat"` session for drafting a new GitHub issue.
+
+Used by `coord new-issue-chat <repo>` (the CLI command shelled out by the
+TUI's "New issue" action).  Seeds the worker with the repo's CLAUDE.md, the
+per-repo new-issue guidance from ``coordinator.yml``, and a bounded list of
+recently open issues so the chat can flag near-duplicates.  The developer
+drives the conversation; the worker helps articulate intent and produces a
+finished issue body in the ``TITLE: / --- / body`` format.
+
+The session runs as a ``type="new-issue-chat"`` assignment on an agent server.
+Tools are restricted to ``Read,Bash`` with a deny list that blocks all
+mutations (``gh issue create``, ``git push``, etc.) — the user-side TUI
+handles the actual ``gh issue create`` submission.
+"""
+from __future__ import annotations
+
+import json
+import time
+import uuid
+from pathlib import Path
+
+from coord import github_ops
+from coord.config import Config
+from coord.models import Machine, Proposal, Repo
+from coord.refine_chat import _read_claude_md
+
+# How many open issues to fetch for near-duplicate detection.
+MAX_OPEN_ISSUES = 20
+
+
+def pick_new_issue_chat_machine(cfg: Config, repo: str) -> Machine | None:
+    """Pick a machine to run the new-issue-chat session on.
+
+    Returns the first unpaused machine that lists *repo* and has a resolved
+    ``repo_path`` for it.  New-issue-chat is read-only and short-lived, so
+    any qualified machine works — no freshness / capacity weighting needed.
+    Returns ``None`` when no machine claims the repo.
+    """
+    from coord.machine_pause import paused_set
+
+    paused = paused_set(cfg.machines)
+    for m in cfg.machines:
+        if (
+            m.can_work_on(repo)
+            and m.repo_path(repo) is not None
+            and m.name not in paused
+        ):
+            return m
+    return None
+
+
+def _fetch_open_issues(slug: str, limit: int = MAX_OPEN_ISSUES) -> list[dict]:
+    """Best-effort fetch of open issue titles from ``gh issue list``.
+
+    Returns a list of ``{"number": int, "title": str}`` dicts, truncated to
+    *limit*.  Returns an empty list on any failure so the seed still works
+    without issue-list context.
+    """
+    try:
+        raw = github_ops._gh(
+            "issue", "list",
+            "--repo", slug,
+            "--state", "open",
+            "--limit", str(limit),
+            "--json", "number,title",
+        )
+        data = json.loads(raw)
+        if not isinstance(data, list):
+            return []
+        return data[:limit]
+    except (RuntimeError, ValueError, json.JSONDecodeError):
+        return []
+
+
+def build_new_issue_briefing(
+    *,
+    repo_slug: str,
+    claude_md: str,
+    new_issue_guidance: str,
+    open_issues: list[dict],
+) -> str:
+    """Compose the seed briefing the worker sees as its first user message.
+
+    The agent's ``NEW_ISSUE_CHAT_SYSTEM_PROMPT`` already tells it how to
+    behave; this packs the repo context into the first user turn.
+    """
+    parts: list[str] = []
+    parts.append(f"=== New-issue chat context for {repo_slug} ===\n")
+
+    parts.append("ISSUE GUIDANCE (required sections and conventions):")
+    parts.append(new_issue_guidance.strip() if new_issue_guidance.strip() else "(none)")
+    parts.append("")
+
+    parts.append("PROJECT CLAUDE.md:")
+    parts.append(claude_md.strip() if claude_md.strip() else "(not found)")
+    parts.append("")
+
+    parts.append(
+        f"RECENT OPEN ISSUES (last {MAX_OPEN_ISSUES}, check for near-duplicates):"
+    )
+    if open_issues:
+        for issue in open_issues:
+            num = issue.get("number", "?")
+            title = (issue.get("title") or "").strip()
+            parts.append(f"  #{num}: {title}")
+    else:
+        parts.append("  (none fetched)")
+    parts.append("")
+
+    parts.append("---")
+    parts.append(
+        "The developer will now describe the feature or bug they want to file "
+        "as an issue. Ask focused clarifying questions to help shape a "
+        "well-structured draft. When ready, present the draft in the "
+        "TITLE: / --- / body format."
+    )
+    return "\n".join(parts)
+
+
+def dispatch_new_issue_chat(
+    repo_name: str,
+    config: Config,
+    *,
+    machine_override: str | None = None,
+) -> tuple[str, str]:
+    """End-to-end: pick a machine, seed the briefing, dispatch a
+    ``type="new-issue-chat"`` assignment.  Returns ``(assignment_id, machine_name)``.
+
+    Raises ``RuntimeError`` when the repo is unknown, no machine claims it,
+    or the agent rejects the dispatch.
+    """
+    repo_cfg = config.repo(repo_name)
+    if repo_cfg is None:
+        raise RuntimeError(
+            f"repo {repo_name!r} not in coordinator.yml"
+        )
+
+    # Pick the machine.
+    if machine_override:
+        machine = next(
+            (m for m in config.machines if m.name == machine_override),
+            None,
+        )
+        if machine is None:
+            raise RuntimeError(
+                f"machine {machine_override!r} not in coordinator.yml"
+            )
+        if not machine.can_work_on(repo_name):
+            raise RuntimeError(
+                f"machine {machine_override!r} does not list repo {repo_name!r}"
+            )
+    else:
+        picked = pick_new_issue_chat_machine(config, repo_name)
+        if picked is None:
+            raise RuntimeError(
+                f"no machine claims repo {repo_name!r} — new-issue-chat needs a "
+                "machine that has the repo cloned to read CLAUDE.md"
+            )
+        machine = picked
+
+    repo_path = machine.repo_path(repo_name)
+    if repo_path is None:
+        raise RuntimeError(
+            f"machine {machine.name!r} has no resolved path for repo {repo_name!r}"
+        )
+
+    # Read local context (coordinator's view of the repo).
+    repo_root = Path(repo_path).expanduser()
+    claude_md = _read_claude_md(repo_root)
+    new_issue_guidance = repo_cfg.resolve_new_issue_guidance(repo_root)
+    open_issues = _fetch_open_issues(repo_cfg.github)
+
+    briefing = build_new_issue_briefing(
+        repo_slug=repo_cfg.github,
+        claude_md=claude_md,
+        new_issue_guidance=new_issue_guidance,
+        open_issues=open_issues,
+    )
+
+    resolved_model = config.models.default
+    proposal = Proposal(
+        id=0,
+        machine_name=machine.name,
+        repo_name=repo_name,
+        # No existing issue — use 0 as a sentinel.  The DB column is NOT NULL
+        # but there is no issue to reference yet.
+        issue_number=0,
+        issue_title="(new issue draft)",
+        rationale="new-issue-chat",
+        briefing=briefing,
+        model=resolved_model,
+        type="new-issue-chat",
+        required_gates=[],
+    )
+
+    from coord.dispatch import dispatch_with_retry
+    from coord.models import Assignment
+    from coord.state import record_dispatched_assignment
+
+    response = dispatch_with_retry(
+        proposal,
+        config,
+        max_retries=config.concurrency.max_retries,
+        backoff_base=config.concurrency.backoff_base,
+    )
+
+    assignment_id = response.get("id") or uuid.uuid4().hex[:12]
+
+    # Persist the assignment row so the TUI / notify / board can find it.
+    asg = Assignment(
+        machine_name=machine.name,
+        repo_name=repo_name,
+        issue_number=0,
+        issue_title="(new issue draft)",
+        files_allowed=[],
+        files_forbidden=[],
+        briefing=briefing,
+        assignment_id=assignment_id,
+        status="running",
+        dispatched_at=time.time(),
+        type="new-issue-chat",
+        model=resolved_model,
+    )
+    record_dispatched_assignment(
+        assignment=asg,
+        repo_github=repo_cfg.github,
+    )
+
+    return assignment_id, machine.name