devops-bot-sdk 1.6.37__tar.gz → 1.6.38__tar.gz

{devops_bot_sdk-1.6.37 → devops_bot_sdk-1.6.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.37
+Version: 1.6.38
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.6.37 → devops_bot_sdk-1.6.38}/devops_bot_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.37
+Version: 1.6.38
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.6.37 → devops_bot_sdk-1.6.38}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ sdk/exceptions.py
 sdk/firewall.py
 sdk/formats.py
 sdk/git_ops.py
+sdk/github_fetch.py
 sdk/github_ingest.py
 sdk/graph_recon.py
 sdk/graphify.py
@@ -108,6 +109,7 @@ sdk/ui/server.py
 sdk/ui/service.py
 sdk/ui/session.py
 sdk/ui/setup_manager.py
+sdk/ui/swagger.py
 sdk/ui/static/agents.html
 sdk/ui/static/app.js
 sdk/ui/static/chat.html
@@ -143,13 +145,16 @@ tests/test_epic_decompose_run.py
 tests/test_epic_inherited_agent_id.py
 tests/test_epic_session_isolation.py
 tests/test_estimator.py
+tests/test_firewall_open_on_update.py
 tests/test_formats.py
 tests/test_git_action.py
+tests/test_github_fetch.py
 tests/test_github_ingest.py
 tests/test_graph_recon.py
 tests/test_graphify_build.py
 tests/test_graphify_hook_install.py
 tests/test_health.py
+tests/test_intake_job_outcome.py
 tests/test_intake_plan_review.py
 tests/test_journal.py
 tests/test_local_exec_provider.py

{devops_bot_sdk-1.6.37 → devops_bot_sdk-1.6.38}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.6.37
+Version: 1.6.38
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -34,7 +34,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.6.37"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.38"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
 __author__  = "AgentOS"   # sdk.client.SDK_VERSION and the UI server version all read this.
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.6.37 → devops_bot_sdk-1.6.38}/sdk/cli.py

@@ -58,14 +58,18 @@ Command surface:
     agentos integration rm <name>
         Remove a registered integration.
 
-    agentos firewall [--apply] [--revoke IP] [--port N]
+    agentos firewall [--apply] [--any] [--revoke IP] [--port N]
         Print the host-firewall rules that open the agentos-ui port to every IP in
         the application allowlist (`sdk.config.get_allowed_ips`), for THIS OS — ufw
         on Linux, `netsh advfirewall` on Windows, a pf note on macOS. Prints by
         default; `--apply` executes them and needs root / Administrator. The host
         firewall is a separate layer the allowlist cannot reach, and the two drifting
         apart is what silently blinded every VPS when the backend's egress IP moved.
-        See sdk.firewall.
+        `--any` opens the port to every source instead, leaving
+        IPAllowlistMiddleware as the gate — the more robust choice when the
+        backend's egress IP can move, since a stale per-IP kernel rule drops the
+        SYN before the allowlist is ever consulted. This is what runs
+        automatically after a self-update. See sdk.firewall.
 
     agentos swagger [--open] [--json [PATH]] [--port N]
         Where the panel's Swagger UI is and whether it can actually be reached:
@@ -193,6 +197,7 @@ def _print_usage() -> None:
     print("  agentos report <submit|list|show ID>                 # report work Jira/GitHub never saw")
     print("  agentos browser <login URL|status|logout>            # sign in once; private links become readable")
     print("  agentos firewall [--apply] [--revoke IP] [--port N]  # open the UI port to the allowlisted IPs")
+    print("  agentos firewall --any [--apply]                     # open the UI port to any source (allowlist is the gate)")
     print("  agentos swagger [--open] [--json [PATH]]             # where /docs is, and can you reach it")
 
 

{devops_bot_sdk-1.6.37 → devops_bot_sdk-1.6.38}/sdk/client.py

@@ -1025,6 +1025,48 @@ class BackendClient:
             self.last_ingest_error = {"status": 0, "body": str(exc)[:500], "retryable": True}
             return None
 
+    async def ingest_github_prs_raw(self, prs: list[dict],
+                                    since: str | None = None) -> dict | None:
+        """POST {AI}/api/v1/github/prs/raw — PRs THIS machine already fetched.
+
+        The counterpart to :meth:`ingest_github_prs`. That one asks the backend to
+        fetch with a GitHub token the platform has to hold; this one sends records
+        `sdk.github_fetch` produced with the developer's own `gh`, so no GitHub
+        credential exists on the platform at all, the request runs under that
+        developer's own rate limit, and their private repos resolve.
+
+        Only PR DATA travels. The backend resolves the GitHub username and user id
+        from the ``co_`` token server-side and files the records under those, so this
+        cannot be used to attribute PRs to anyone else.
+
+        Same contract as `ingest_github_prs`: the response JSON on success,
+        **None** on any failure, with the reason in ``self.last_ingest_error``.
+        """
+        self.last_ingest_error = {}
+        body: dict = {"prs": prs}
+        if since:
+            body["date_from"] = since
+        try:
+            async with httpx.AsyncClient(timeout=120.0) as client:
+                resp = await client.post(
+                    self._url("/api/v1/github/prs/raw"), json=body, headers=self._headers,
+                )
+            if resp.status_code >= 400:
+                detail = resp.text[:500]
+                logger.warning("client.ingest_github_prs_raw failed status=%s body=%s",
+                               resp.status_code, detail[:200])
+                self.last_ingest_error = {
+                    "status": resp.status_code,
+                    "body": detail,
+                    "retryable": is_retryable_backend_error(resp.status_code, detail),
+                }
+                return None
+            return resp.json()
+        except Exception as exc:  # noqa: BLE001 — a cron must not die on a blip
+            logger.warning("client.ingest_github_prs_raw error err=%s", exc)
+            self.last_ingest_error = {"status": 0, "body": str(exc)[:500], "retryable": True}
+            return None
+
     async def move_to_backlog(self, task_id: str) -> bool:
         """PUT {BE}/tasks-ml/{id} status=backlog (best-effort).
 

{devops_bot_sdk-1.6.37 → devops_bot_sdk-1.6.38}/sdk/firewall.py

@@ -13,10 +13,17 @@ dropped the SYN before the server ever saw it (`docs/VPS_HEALTH_AND_GITHUB_INGES
 _DIAGNOSIS.md` #5). This module closes that gap by deriving the firewall rules
 from the *same* list the middleware enforces, so the two layers cannot drift.
 
-    agentos firewall              # show the rules for this OS (safe, prints only)
+    agentos firewall              # show the per-IP rules for this OS (prints only)
     agentos firewall --apply      # run them (needs root / Administrator)
+    agentos firewall --any        # show the open-to-any rule instead
+    agentos firewall --any --apply# open the port, leaving the allowlist as the gate
     agentos firewall --revoke IP  # print the matching delete rule
 
+``--any`` is also what runs automatically after a self-update
+(``updater._ensure_firewall``), because a pip upgrade replaces code and
+nothing else — a host whose kernel drops the SYNs stays broken across every
+update while reporting a healthy version.
+
 Applying is deliberately opt-in: editing a live firewall is exactly the operation
 that can lock an operator out of their own box, so the default is to print and let
 a human read it first.
@@ -87,6 +94,131 @@ def allow_rules(ips: list[str], port: int, system: str | None = None) -> list[st
     return out
 
 
+def allow_any_rules(port: int, system: str | None = None) -> list[str]:
+    """The commands that open ``port`` to ANY source — one per OS.
+
+    Deliberately different from :func:`allow_rules`, which scopes each rule to an
+    allowlisted IP. Both exist because they fail in opposite directions:
+
+    * **Per-IP rules go stale silently.** The kernel rule names an address, so the
+      day the backend's egress moves the SYNs are dropped before the server sees
+      them — the allowlist still says yes, and the symptom is a 30s hang then a
+      502. That is not hypothetical: it is the incident in this module's own
+      docstring (``20.127.87.169``), and it blinded every VPS at once.
+    * **An open port is only safe because it is not the real gate.**
+      ``IPAllowlistMiddleware`` still refuses every request from an
+      unlisted source, and it is reachable over the API — so access can be
+      corrected in seconds without root on the box, which is exactly what a
+      kernel rule cannot offer.
+
+    So: open the port, keep the decision in the allowlist. Use
+    :func:`allow_rules` instead when the host must not accept a connection from
+    an unlisted address at all (a shared or hostile network), and accept that a
+    backend IP change then needs a root session on every host.
+    """
+    sysname = (system or _system()).lower()
+
+    if sysname == "linux":
+        # `/tcp` and not a bare `allow 8765`: the bare form opens UDP too, and the
+        # server has never listened on UDP. Re-running is harmless — ufw reports
+        # "Skipping adding existing rule".
+        return [f"sudo ufw allow {port}/tcp comment '{_RULE_TAG}'"]
+    if sysname == "windows":
+        # No `remoteip=` — that omission IS the "any source" part. The stable
+        # `name=` is what makes the rule findable and removable later.
+        return [
+            f'netsh advfirewall firewall add rule name="{_RULE_TAG} {port} any" '
+            f"dir=in action=allow protocol=TCP localport={port}"
+        ]
+    if sysname == "darwin":
+        return [
+            f"# macOS (pf) — append to /etc/pf.anchors/agentos then reload:\n"
+            f"#   pass in proto tcp from any to any port {port}\n"
+            f"sudo pfctl -f /etc/pf.conf && sudo pfctl -E"
+        ]
+    return [f"# unsupported platform {sysname!r} — open TCP {port} inbound"]
+
+
+def revoke_any_rule(port: int, system: str | None = None) -> str:
+    """The command that removes the open-to-any rule for ``port``."""
+    sysname = (system or _system()).lower()
+    if sysname == "linux":
+        return f"sudo ufw delete allow {port}/tcp"
+    if sysname == "windows":
+        return f'netsh advfirewall firewall delete rule name="{_RULE_TAG} {port} any"'
+    if sysname == "darwin":
+        return ("# macOS: remove the matching line from /etc/pf.anchors/agentos, "
+                "then: sudo pfctl -f /etc/pf.conf")
+    return f"# unsupported platform {sysname!r}"
+
+
+def ensure_open(port: int | None = None, *, apply: bool = True) -> tuple[bool, str]:
+    """Make sure ``port`` is reachable. Returns ``(changed, message)``. Never raises.
+
+    Built for the post-update hook, so every branch is a no-op-or-explain rather
+    than a failure:
+
+    * already open (or open to a superset) → ``(False, "…already open…")`` and
+      **no command is run**. This is the common case on the second and every
+      later update, and it is why the hook is cheap enough to run every time.
+    * state unreadable (no tool, or unprivileged) → ``(False, <the command>)``.
+      Unreadable is NEVER treated as closed: `port_sources` returns ``None`` for
+      "cannot tell", and acting on that as though the port were shut would run a
+      firewall edit on a host whose state we do not know.
+    * closed and privileged → apply, and report what happened.
+    * closed and unprivileged → print nothing, return the command so the caller
+      can show it. An update runs unattended; it must not stall waiting for sudo.
+
+    macOS never applies: pf rules live in a file, so there is no command to run.
+    """
+    port = ui_port() if port is None else port
+    sysname = _system()
+
+    try:
+        sources = port_sources(port, sysname)
+    except Exception:  # noqa: BLE001 — a status probe must never break an update
+        sources = None
+
+    if sources:
+        if "Anywhere" in sources:
+            return (False, f"TCP {port} is already open to any source")
+        return (False, f"TCP {port} is already open to: {', '.join(sorted(sources))}")
+
+    rules = allow_any_rules(port, sysname)
+    printable = "  " + "\n  ".join(rules)
+
+    if sources is None and sysname == "darwin":
+        return (False, f"macOS: pf state is not readable and pf rules are file-based —\n{printable}")
+    if sources is None:
+        ok, tool = _tool_present()
+        why = tool if not ok else "needs root to read the firewall state"
+        return (False, f"could not read the firewall state ({why}) — to open it yourself:\n{printable}")
+
+    # Readable and genuinely empty for this port.
+    if not apply or sysname == "darwin":
+        return (False, f"TCP {port} is not open. To open it:\n{printable}")
+    if not _is_privileged():
+        who = "Administrator" if sysname == "windows" else "root (sudo)"
+        return (False, f"TCP {port} is not open and opening it needs {who}:\n{printable}")
+
+    failed: list[str] = []
+    for rule in rules:
+        cmd = rule[len("sudo "):] if rule.startswith("sudo ") else rule
+        try:
+            proc = subprocess.run(
+                cmd, shell=True, capture_output=True, text=True, timeout=30,
+            )
+        except Exception as exc:  # noqa: BLE001
+            failed.append(f"{cmd}: {exc}")
+            continue
+        if proc.returncode != 0:
+            tail = (proc.stderr or proc.stdout or "").strip().splitlines()
+            failed.append(f"{cmd}: {tail[-1][:120] if tail else f'exit {proc.returncode}'}")
+    if failed:
+        return (False, "could not open TCP %d: %s" % (port, "; ".join(failed)))
+    return (True, f"opened TCP {port} inbound")
+
+
 def revoke_rule(ip: str, port: int, system: str | None = None) -> str:
     """The command that removes the rule for one ``ip``."""
     sysname = (system or _system()).lower()
@@ -249,6 +381,36 @@ def cli(argv: list[str]) -> int:
     print(f"UI port  : {port}")
     print(f"Allowed  : {', '.join(ips) if ips else '(none — loopback only)'}")
 
+    # `--any` opens the port to every source and leaves the decision to
+    # IPAllowlistMiddleware. This is what the post-update hook uses; see
+    # `allow_any_rules` for why a per-IP kernel rule is the more fragile of the
+    # two. It does NOT need an allowlist to be populated first, so it is checked
+    # before the "nothing to open" bail below.
+    if "--any" in argv or "--open" in argv:
+        current = port_sources(port, sysname)
+        if current:
+            where = "any source" if "Anywhere" in current else ", ".join(sorted(current))
+            print(f"\nAlready open to: {where}")
+            if "Anywhere" not in current and "--apply" not in argv:
+                print("Re-run with --any --apply to widen it to any source.")
+            if "Anywhere" in current:
+                return 0
+        elif current is None:
+            print("\n(firewall state unreadable — showing the rule anyway)")
+
+        rules = allow_any_rules(port, sysname)
+        print("\nOpen the port to any source:\n")
+        for r in rules:
+            print(f"  {r}")
+        print("\nAccess is still gated by the app allowlist above — an unlisted IP is\n"
+              "refused by IPAllowlistMiddleware even with the port open.")
+        if "--apply" not in argv:
+            print("\n(dry run — nothing changed. Re-run with --apply to execute.)")
+            return 0
+        changed, msg = ensure_open(port, apply=True)
+        print(f"\n{msg}")
+        return 0 if changed or "already open" in msg else 1
+
     if not ips:
         print("\nNothing to open. Loopback always reaches the server; add the backend's\n"
               "egress IP to AGENTOS_UI_ALLOWED_IPS first.")

devops_bot_sdk-1.6.38/sdk/github_fetch.py

@@ -0,0 +1,198 @@
+"""Fetch this developer's PRs with their own `gh`, in the shape the backend expects.
+
+Every developer installs and authenticates `gh` on their own machine, and one VPS is
+one developer — so `gh` here IS the per-user credential. That makes fetching on this
+side strictly better than the backend doing it:
+
+  * **the platform never holds a GitHub token.** The alternative (Option C in the
+    backend's ``docs/GITHUB_SCHEDULING_SDK_MIGRATION.md``) has the SDK pull a
+    ``gho_`` token from the ML gateway — a long-lived credential copied onto every
+    VPS. With ``gh`` the credential is already here, owned and rotated by the
+    developer, and this module neither reads nor transmits it: ``gh`` does.
+  * **per-user rate limits** — 5000 requests/hour each, rather than every developer
+    contending for one shared pool. The backend fetcher carries an explicit
+    ``search_limit_exhausted`` backoff for exactly that contention.
+  * **private and IP-allowlisted repos** resolve, because the call originates from
+    the machine that has access.
+
+Deliberately ``gh api``, not ``gh search prs``. The latter reshapes results through
+GraphQL: it returns an opaque node id (``PR_kwDO…``) instead of the numeric REST id,
+and has no ``mergedAt`` field at all — so records would not match the backend's and
+the two ingestion paths would drift. ``gh api`` is a thin authenticated proxy to the
+REST endpoint ``modules/ingestion/github_pr_fetcher`` already calls, so the records
+this produces are byte-identical and ``pr_facts()`` needs no per-source branch.
+
+What stays on the backend: the LLM narrative, the ``content.prs`` facts, the
+daily-summary forward and the Qdrant upsert. ``daily_summaries`` is uniquely keyed on
+``(user_id, date, channel_type, project)``, so one writer must assemble the whole
+record — this module only supplies the raw material, through
+``POST /api/v1/github/prs/raw``.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import shutil
+import subprocess
+
+logger = logging.getLogger("sdk.github_fetch")
+
+# Per-PR file/commit detail costs two extra API calls each, so it is bounded. A
+# developer's weekly window is tens of PRs; a 50-day backfill for a busy one ran 31.
+MAX_DETAIL_PRS = 300
+_GH_TIMEOUT = 60.0
+
+
+class GhUnavailable(RuntimeError):
+    """`gh` is missing, not authenticated, or unusable — with an operator fix."""
+
+
+def gh_available() -> tuple[bool, str]:
+    """``(ok, detail)`` — is `gh` installed AND authenticated for api calls?
+
+    Checked as two separate failures because the fixes differ: an absent binary is
+    an install, a rejected token is ``gh auth login``. Never raises.
+    """
+    if not shutil.which("gh"):
+        return False, ("`gh` is not installed — install the GitHub CLI "
+                       "(https://cli.github.com) and run `gh auth login`")
+    try:
+        proc = subprocess.run(["gh", "auth", "status"], capture_output=True,
+                              text=True, timeout=20, check=False)
+    except Exception as exc:  # noqa: BLE001 — a hung probe is an unavailable gh
+        return False, f"`gh auth status` failed: {exc}"
+    if proc.returncode != 0:
+        return False, ("`gh` is installed but not authenticated — run "
+                       "`gh auth login` as the user this service runs as")
+    account = ""
+    for line in (proc.stdout or proc.stderr or "").splitlines():
+        if "Logged in to" in line:
+            account = line.strip().lstrip("✓- ").strip()
+            break
+    return True, account or "authenticated"
+
+
+def _gh_api(path: str, params: dict | None = None) -> object:
+    """One `gh api` GET, parsed. Raises :class:`GhUnavailable` on failure.
+
+    `gh` owns the credential, the base URL, and retry/paging headers — this only
+    shapes the request and reads stdout.
+    """
+    cmd = ["gh", "api", "-X", "GET", path]
+    for key, value in (params or {}).items():
+        cmd += ["-f", f"{key}={value}"]
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True,
+                              timeout=_GH_TIMEOUT, check=False)
+    except subprocess.TimeoutExpired as exc:
+        raise GhUnavailable(f"`gh api {path}` timed out after {_GH_TIMEOUT}s") from exc
+    except Exception as exc:
+        raise GhUnavailable(f"`gh api {path}` could not run: {exc}") from exc
+    if proc.returncode != 0:
+        detail = (proc.stderr or proc.stdout or "").strip().splitlines()
+        raise GhUnavailable(f"`gh api {path}` failed: {detail[-1] if detail else '?'}")
+    try:
+        return json.loads(proc.stdout or "null")
+    except json.JSONDecodeError as exc:
+        raise GhUnavailable(f"`gh api {path}` returned non-JSON: {exc}") from exc
+
+
+def _repo_full_name(item: dict) -> str:
+    """``owner/name`` from a search item's ``repository_url``."""
+    parts = (item.get("repository_url") or "").rstrip("/").split("/")
+    return "/".join(parts[-2:]) if len(parts) >= 2 else ""
+
+
+def _detail(repo: str, number: int) -> tuple[list[dict], list[dict]]:
+    """``(files, commits)`` for one PR, mapped to the backend fetcher's sub-shapes.
+
+    Both are best-effort: a PR whose detail cannot be read still ingests with empty
+    lists, exactly as the backend fetcher does, because the narrative degrades but
+    the countable facts do not depend on it.
+    """
+    files: list[dict] = []
+    commits: list[dict] = []
+    try:
+        raw = _gh_api(f"repos/{repo}/pulls/{number}/files", {"per_page": 100})
+        files = [
+            {"filename": f.get("filename"), "status": f.get("status"),
+             "additions": f.get("additions"), "deletions": f.get("deletions"),
+             "changes": f.get("changes")}
+            for f in (raw or []) if isinstance(f, dict)
+        ]
+    except GhUnavailable as exc:
+        logger.warning("github_fetch.files_failed repo=%s pr=%s err=%s", repo, number, exc)
+    try:
+        raw = _gh_api(f"repos/{repo}/pulls/{number}/commits", {"per_page": 100})
+        for c in (raw or []):
+            if not isinstance(c, dict):
+                continue
+            commit = c.get("commit") or {}
+            author = commit.get("author") or {}
+            commits.append({
+                "sha":     c.get("sha"),
+                "message": commit.get("message"),
+                "author":  author.get("name") or (c.get("author") or {}).get("login"),
+                "email":   author.get("email"),
+                "date":    author.get("date"),
+                "url":     c.get("html_url"),
+            })
+    except GhUnavailable as exc:
+        logger.warning("github_fetch.commits_failed repo=%s pr=%s err=%s", repo, number, exc)
+    return files, commits
+
+
+def fetch_prs(username: str, since: str, *, with_detail: bool = True,
+              max_detail: int = MAX_DETAIL_PRS) -> list[dict]:
+    """PRs authored by ``username`` updated on/after ``since`` (``YYYY-MM-DD``).
+
+    ``updated:>=``, not ``created:>=``: a PR opened five weeks ago and merged
+    yesterday has to come back inside a 7-day window, or the daily-summary record
+    for its creation day is never rewritten and its ``mergedAt`` stays null forever.
+    The backend files each PR under its own creation date regardless, so widening
+    this changes which PRs are returned, not which day each lands on.
+
+    Returns records in ``modules.ingestion.github_pr_fetcher``'s shape, so the
+    backend can use them without a per-source branch. Raises
+    :class:`GhUnavailable` if `gh` cannot serve the request — the caller decides
+    whether that is fatal or a reason to fall back to server-side fetching.
+    """
+    query = f"is:pr author:{username} updated:>={since}"
+    items: list[dict] = []
+    page = 1
+    while page <= 10:                      # 10 x 100 = the search API's own ceiling
+        body = _gh_api("search/issues", {"q": query, "per_page": 100, "page": page})
+        batch = (body or {}).get("items") or [] if isinstance(body, dict) else []
+        items.extend(i for i in batch if isinstance(i, dict))
+        if len(batch) < 100:
+            break
+        page += 1
+
+    out: list[dict] = []
+    for idx, item in enumerate(items):
+        repo = _repo_full_name(item)
+        number = item.get("number")
+        files: list[dict] = []
+        commits: list[dict] = []
+        if with_detail and repo and number and idx < max_detail:
+            files, commits = _detail(repo, number)
+        out.append({
+            "id":            item.get("id"),
+            "number":        number,
+            "title":         item.get("title"),
+            "state":         item.get("state"),
+            "author":        (item.get("user") or {}).get("login"),
+            "createdAt":     item.get("created_at"),
+            "updatedAt":     item.get("updated_at"),
+            "closedAt":      item.get("closed_at"),
+            "mergedAt":      (item.get("pull_request") or {}).get("merged_at"),
+            "draft":         item.get("draft", False),
+            "url":           item.get("html_url"),
+            "repository":    repo,
+            "commentsCount": item.get("comments", 0),
+            "files":         files,
+            "commits":       commits,
+        })
+    logger.info("github_fetch.done user=%s since=%s prs=%d detail=%s",
+                username, since, len(out), with_detail)
+    return out

{devops_bot_sdk-1.6.37 → devops_bot_sdk-1.6.38}/sdk/github_ingest.py

@@ -370,6 +370,27 @@ def since_for(now: datetime, state: dict, days: int | None = None) -> str:
 
 # ── One run ─────────────────────────────────────────────────────────────────
 
+def _fetch_locally(username: str, since: str) -> tuple[list[dict] | None, str]:
+    """``(prs, note)`` from this machine's `gh`, or ``(None, why-not)``.
+
+    ``None`` means "could not fetch here" and the caller should let the backend do
+    it — an absent or unauthenticated `gh`, or a `gh` that errored. An empty LIST
+    means "fetched fine, this developer has no PRs in the window", which is a
+    different answer and must not trigger a fallback.
+    """
+    from sdk.github_fetch import GhUnavailable, fetch_prs, gh_available
+
+    ok, detail = gh_available()
+    if not ok:
+        logger.info("github_ingest.gh_unavailable %s", detail)
+        return None, detail
+    try:
+        return fetch_prs(username, since), detail
+    except GhUnavailable as exc:
+        logger.warning("github_ingest.gh_fetch_failed err=%s", exc)
+        return None, str(exc)
+
+
 async def run_once(client: "BackendClient | None" = None, *, now: datetime | None = None,
                    days: int | None = None) -> dict:
     """Resolve this user's GitHub link, POST the ingest request, record the outcome.
@@ -406,12 +427,36 @@ async def run_once(client: "BackendClient | None" = None, *, now: datetime | Non
             save_state(state)
             return out
 
-        # No credentials in the call: the backend resolves the GitHub link
-        # server-side from the co_ token and overwrites anything the body sends
+        # Fetch HERE when `gh` can, and only ask the backend to fetch when it
+        # cannot. `gh` is authenticated per developer and one VPS is one developer,
+        # so fetching locally means the platform holds no GitHub token, the request
+        # runs under this developer's own rate limit, and their private and
+        # IP-allowlisted repos resolve. Falling back keeps a box without `gh`
+        # working exactly as before rather than silently ingesting nothing.
+        #
+        # Either way NO credentials go in the body: the backend resolves the GitHub
+        # link server-side from the co_ token and overwrites anything sent
         # (docs/GITHUB_SCHEDULING_SDK_MIGRATION.md §7/§9). The record fetched above
         # is still worth having — it is how `no_github_link` is answered without a
         # wasted round-trip.
-        resp = await client.ingest_github_prs(since=since)
+        local_prs, fetch_note = _fetch_locally(username, since)
+        if local_prs is None:
+            out["fetch"] = f"backend ({fetch_note})"
+            resp = await client.ingest_github_prs(since=since)
+        elif not local_prs:
+            # `gh` worked and this developer genuinely has no PRs in the window.
+            # Posting an empty list would be a 422, and asking the backend to look
+            # again would just spend its rate limit to reach the same answer.
+            out.update({"ok": True, "status": "no_prs", "fetch": "local"})
+            logger.info("github_ingest.no_prs since=%s", since)
+            state.update({"last_run_at": stamp.isoformat(), "last_status": "no_prs",
+                          "backfill_id": BACKFILL_ID})
+            save_state(state)
+            return out
+        else:
+            out["fetch"] = "local"
+            out["prs_fetched"] = len(local_prs)
+            resp = await client.ingest_github_prs_raw(local_prs, since=since)
         if resp is None:
             err = getattr(client, "last_ingest_error", {}) or {}
             retryable = bool(err.get("retryable"))