devops-bot-sdk 1.5.0__tar.gz → 1.6.2__tar.gz

{devops_bot_sdk-1.5.0 → devops_bot_sdk-1.6.2}/PKG-INFO

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

{devops_bot_sdk-1.5.0 → devops_bot_sdk-1.6.2}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.5.0 → devops_bot_sdk-1.6.2}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.5.0
+Version: 1.6.2
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -30,7 +30,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.5.0"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.2"   # 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.5.0 → devops_bot_sdk-1.6.2}/sdk/github_ingest.py

@@ -13,6 +13,16 @@ What moves and what does NOT:
     Postgres, Qdrant, or Azure, and holds no credential beyond the ``co_`` token
     it was configured with. One VPS cannot write another user's vectors.
 
+**Two things run, both on by default, no configuration needed:**
+  1. a ONE-TIME 50-day history backfill, fired from ``agentos-auto update`` via
+     :func:`run_backfill_once` and guarded by ``BACKFILL_ID`` so it happens at
+     most once per machine;
+  2. the DAILY loop below, started by the ``agentos-ui`` lifespan alongside the
+     2-hourly ``sdk.vps_health`` ping.
+
+The daily loop also covers the backfill: if a box never runs ``agentos-auto
+update``, the first tick sees ``backfill_pending`` and seeds the history itself.
+
 Schedule semantics — a real daily slot, not a naive interval:
   * the loop ticks every ``_TICK_S`` (cheap: no network unless a run is due),
   * a run is DUE when the UTC clock has passed ``AGENTOS_GITHUB_INGEST_AT``
@@ -31,7 +41,9 @@ State lives in ``~/.agentos/github_ingest.json``: ``last_success_at`` (the
 watermark), plus the last attempt's outcome for ``GET /api/ui/github-ingest``.
 
 Config — process env OR ``~/.agentos/.env`` (process env wins), all optional:
-  ``AGENTOS_GITHUB_INGEST``      ``0``/``false``/``no``/``off`` disables the cron.
+  ``AGENTOS_GITHUB_INGEST``      ``0``/``false``/``no``/``off`` disables everything.
+  ``AGENTOS_GITHUB_INGEST_DAILY``  ``0`` turns the recurring daily loop OFF (default ON).
+  ``AGENTOS_GITHUB_INGEST_BACKFILL_DAYS``  one-time seed size (default 50, max 365).
   ``AGENTOS_GITHUB_INGEST_AT``   daily UTC slot, ``HH:MM`` (default ``13:30``).
   ``AGENTOS_GITHUB_INGEST_LOOKBACK_DAYS``  catch-up cap (default 7, max 90).
 
@@ -88,10 +100,24 @@ def _setting(name: str) -> str:
 
 
 def enabled() -> bool:
-    """True unless ``AGENTOS_GITHUB_INGEST`` is explicitly falsey (opt-OUT)."""
+    """Master switch — False only when ``AGENTOS_GITHUB_INGEST`` is explicitly falsey.
+
+    Gates BOTH the one-time backfill and the daily loop.
+    """
     return _setting("AGENTOS_GITHUB_INGEST").lower() not in _FALSEY
 
 
+def daily_enabled() -> bool:
+    """Is the RECURRING daily loop switched on? **Default: yes.**
+
+    The steady state is two schedules running side by side on every box, with no
+    configuration required: ``sdk.vps_health`` every 2 hours, and this one daily
+    at :func:`slot`. Opt OUT with ``AGENTOS_GITHUB_INGEST_DAILY=0`` (or turn off
+    GitHub ingestion entirely with ``AGENTOS_GITHUB_INGEST=0``).
+    """
+    return _setting("AGENTOS_GITHUB_INGEST_DAILY").lower() not in _FALSEY
+
+
 def slot() -> tuple[int, int]:
     """The daily UTC slot as ``(hour, minute)``. Bad values fall back to the default."""
     raw = _setting("AGENTOS_GITHUB_INGEST_AT") or DEFAULT_AT
@@ -307,6 +333,7 @@ def status() -> dict:
     state = load_state()
     return {
         "enabled": enabled(),
+        "daily_loop": daily_enabled(),
         "slot_utc": f"{hour:02d}:{minute:02d}",
         "lookback_days": lookback_days(),
         "backfill_days": backfill_days(),
@@ -338,8 +365,44 @@ async def run_forever(tick_s: float = _TICK_S) -> None:
 
 
 def start() -> "asyncio.Task | None":
-    """Start the cron as a background task when enabled. Returns the task (or None)."""
+    """Start the RECURRING daily loop. On by default; returns the task, or None
+    when GitHub ingestion (or just the daily loop) has been switched off."""
     if not enabled():
         logger.info("github_ingest.disabled (AGENTOS_GITHUB_INGEST is off)")
         return None
+    if not daily_enabled():
+        logger.info("github_ingest.daily_loop_off (AGENTOS_GITHUB_INGEST_DAILY is off)")
+        return None
     return asyncio.ensure_future(run_forever())
+
+
+# ── The one-time backfill (what `agentos-auto update` fires) ────────────────
+
+def run_backfill_once(client: "BackendClient | None" = None) -> dict:
+    """Run THIS rollout's 50-day history backfill — at most once per machine.
+
+    Called from ``agentos-auto update``. Safe to call on every update: the
+    ``BACKFILL_ID`` marker in ``~/.agentos/github_ingest.json`` means the second
+    and later calls are a no-op, so a user who updates weekly still ingests the
+    history exactly once.
+
+    Synchronous by design — the update command is a plain CLI flow, not an event
+    loop. Returns ``{ran, status, since, job_id, status_url, reason}``;
+    ``ran=False`` with ``status="already_done"`` when the marker is already set,
+    or ``"disabled"`` when the feature is switched off. Never raises: a failed
+    backfill must not fail the update.
+    """
+    if not enabled():
+        return {"ran": False, "status": "disabled", "reason": "AGENTOS_GITHUB_INGEST is off"}
+
+    state = load_state()
+    if not backfill_pending(state):
+        return {"ran": False, "status": "already_done",
+                "since": state.get("last_since", ""), "job_id": state.get("last_job_id", "")}
+
+    try:
+        result = asyncio.run(run_once(client, days=backfill_days()))
+    except Exception as exc:  # noqa: BLE001 — never fail `agentos-auto update`
+        logger.warning("github_ingest.backfill_failed err=%s", exc)
+        return {"ran": True, "status": "failed", "reason": str(exc)[:200]}
+    return {"ran": True, **result}

{devops_bot_sdk-1.5.0 → devops_bot_sdk-1.6.2}/sdk/run_auto.py

@@ -588,6 +588,47 @@ def main() -> None:
                       "`agentos-auto stop` then `agentos-auto` to run the new one.")
         else:
             print(f"already up to date (v{after})")
+
+        # One-time GitHub history backfill — the last 50 days of THIS user's PRs.
+        # Fired from `update` because that is the moment every machine passes
+        # through exactly once per rollout. Guarded by the BACKFILL_ID marker in
+        # ~/.agentos/github_ingest.json, so a second `update` is a no-op — and it
+        # runs whether or not the version actually changed, so a box that was
+        # already current still seeds its history. Never fails the update.
+        try:
+            from sdk import github_ingest
+
+            gh = github_ingest.run_backfill_once()
+            status = gh.get("status")
+            if gh.get("ran") and status == "queued":
+                print(f"✓ GitHub history: queued PRs since {gh.get('since')} "
+                      f"(job {gh.get('job_id') or 'n/a'})")
+            elif gh.get("ran") and status == "no_github_link":
+                print("  GitHub history: skipped — no GitHub account connected")
+            elif gh.get("ran"):
+                print(f"  GitHub history: not queued — {gh.get('reason') or status}")
+            elif status == "already_done":
+                print("  GitHub history: already ingested")
+        except Exception as exc:  # noqa: BLE001 — never fail the update on this
+            print(f"  GitHub history: skipped ({exc})")
+
+        # Refresh this machine's health immediately. The panel pings every 2h on
+        # its own, but an update restarts the panel — so without this the
+        # allocation row can look stale for up to two hours right after a rollout,
+        # which is exactly when someone is checking whether the box came back.
+        try:
+            import asyncio as _asyncio
+
+            from sdk import vps_health
+
+            if vps_health.enabled():
+                if _asyncio.run(vps_health.report_once()):
+                    print("✓ VPS health: reported")
+                else:
+                    last = (vps_health.last_report().get("last") or {})
+                    print(f"  VPS health: not reported — {last.get('reason') or 'unknown'}")
+        except Exception as exc:  # noqa: BLE001 — never fail the update on this
+            print(f"  VPS health: skipped ({exc})")
         return
 
     if cmd == "stop":

{devops_bot_sdk-1.5.0 → devops_bot_sdk-1.6.2}/tests/test_github_ingest.py

@@ -24,7 +24,8 @@ def isolated_state(tmp_path, monkeypatch):
     monkeypatch.setattr(gi, "STATE_FILE", tmp_path / "github_ingest.json")
     import sdk.config as cfg
     monkeypatch.setattr(cfg, "_dotenv_value", lambda key: "")
-    for var in ("AGENTOS_GITHUB_INGEST", "AGENTOS_GITHUB_INGEST_AT",
+    for var in ("AGENTOS_GITHUB_INGEST", "AGENTOS_GITHUB_INGEST_DAILY",
+                "AGENTOS_GITHUB_INGEST_AT",
                 "AGENTOS_GITHUB_INGEST_LOOKBACK_DAYS",
                 "AGENTOS_GITHUB_INGEST_BACKFILL_DAYS"):
         monkeypatch.delenv(var, raising=False)
@@ -150,6 +151,14 @@ class TestSinceWindow:
 _UNSET = object()   # so an explicit None ("no link" / "call failed") is distinguishable
 
 
+def _sync_stub(client):
+    """Replace run_once with a coroutine that records the window it was asked for."""
+    async def _fake(c=None, *, now=None, days=None):
+        client.calls.append({"since_days": days})
+        return {"ok": True, "status": "queued", "since": "2026-06-14", "job_id": "job-1"}
+    return _fake
+
+
 class _FakeClient:
     def __init__(self, record=_UNSET, resp=_UNSET):
         self._record = {"username": "nouman", "accessToken": "gho_x"} if record is _UNSET else record
@@ -258,7 +267,23 @@ class TestState:
 
 
 class TestStart:
-    def test_disabled_starts_nothing(self, monkeypatch):
+    def test_daily_loop_is_on_by_default(self):
+        """Steady state: 2-hourly VPS health + this daily loop, no config needed."""
+        assert gi.daily_enabled() is True
+
+        async def go():
+            task = gi.start()
+            assert task is not None
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+            return True
+
+        assert asyncio.run(go()) is True
+
+    def test_master_switch_stops_everything(self, monkeypatch):
         monkeypatch.setenv("AGENTOS_GITHUB_INGEST", "0")
 
         async def go():
@@ -266,7 +291,16 @@ class TestStart:
 
         assert asyncio.run(go()) is None
 
-    def test_enabled_starts_a_task(self):
+    def test_daily_loop_can_be_opted_out(self, monkeypatch):
+        monkeypatch.setenv("AGENTOS_GITHUB_INGEST_DAILY", "0")
+
+        async def go():
+            return gi.start()
+
+        assert asyncio.run(go()) is None
+        assert gi.daily_enabled() is False
+
+    def test_loop_starts_and_cancels_cleanly(self):
         async def go():
             task = gi.start()
             assert task is not None
@@ -280,6 +314,41 @@ class TestStart:
         assert asyncio.run(go()) is True
 
 
+class TestRunBackfillOnce:
+    """What `agentos-auto update` actually calls."""
+
+    def test_first_call_queues_50_days(self, monkeypatch):
+        client = _FakeClient()
+        monkeypatch.setattr(gi, "run_once", _sync_stub(client))
+        out = gi.run_backfill_once(client)
+        assert out["ran"] is True and out["status"] == "queued"
+        assert client.calls[0]["since_days"] == 50
+
+    def test_second_call_is_a_noop(self):
+        gi.save_state({"backfill_id": gi.BACKFILL_ID, "last_job_id": "job-1"})
+        out = gi.run_backfill_once(_FakeClient())
+        assert out["ran"] is False and out["status"] == "already_done"
+
+    def test_respects_the_master_switch(self, monkeypatch):
+        monkeypatch.setenv("AGENTOS_GITHUB_INGEST", "0")
+        out = gi.run_backfill_once(_FakeClient())
+        assert out["ran"] is False and out["status"] == "disabled"
+
+    def test_real_call_marks_it_done(self):
+        """End to end through run_once: queued, then the marker blocks a re-run."""
+        out = gi.run_backfill_once(_FakeClient())
+        assert out["ran"] is True and out["status"] == "queued"
+        assert gi.run_backfill_once(_FakeClient())["status"] == "already_done"
+
+    def test_never_raises_into_the_update(self, monkeypatch):
+        def boom(*a, **k):
+            raise RuntimeError("kaboom")
+
+        monkeypatch.setattr(gi, "run_once", boom)
+        out = gi.run_backfill_once(_FakeClient())
+        assert out["ran"] is True and out["status"] == "failed"
+
+
 # ── Routes ──────────────────────────────────────────────────────────────────
 
 fastapi = pytest.importorskip("fastapi")