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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.5.0
+Version: 1.6.4
 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.4}/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.4
 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.4}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -93,6 +93,7 @@ sdk/ui/static/styles.css
 sdk/ui/static/tickets.html
 tests/test_agent_activity.py
 tests/test_agent_chat_features.py
+tests/test_agent_listing.py
 tests/test_agent_prompt_async.py
 tests/test_agent_prompt_models.py
 tests/test_agent_run_ticket.py

{devops_bot_sdk-1.5.0 → devops_bot_sdk-1.6.4}/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.4
 
 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.4"   # 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.4}/sdk/agents/inventory.py

@@ -37,17 +37,19 @@ def _map_backend_agent(row: dict, source: str) -> dict:
 
 
 async def _custom_agents() -> list[dict]:
-    """The caller's custom agents (``relation_type=person``) from the backend.
+    """The caller's own custom agents (``relation_type='User'``) from the backend.
 
-    Backend is the source of truth — agents are authored in the web app and read
-    via GET /api/v1/agents. Best-effort: degrades to empty on any error.
+    Backend is the source of truth — agents are authored in the web app, owned by
+    the caller's ``users.id``, and read via GET /api/v1/agents. Best-effort:
+    degrades to empty on any error, but logs at WARNING because "this user owns no
+    agents" and "the fetch failed" look identical downstream once both are ``[]``.
     """
     try:
         from sdk.client import BackendClient
         rows = await BackendClient.from_config().list_custom_agents()
         return [_map_backend_agent(r, "custom") for r in rows]
     except Exception as exc:  # noqa: BLE001
-        logger.debug("custom-agent inventory failed: %s", exc)
+        logger.warning("custom-agent inventory failed (listing as empty): %s", exc)
         return []
 
 

{devops_bot_sdk-1.5.0 → devops_bot_sdk-1.6.4}/sdk/cli.py

@@ -201,43 +201,80 @@ def _agent_chat(name: str, message: str) -> None:
         sys.exit(1)
 
 
+def _agent_row_summary(row: dict) -> tuple[str, str]:
+    """``(variables, skills)`` display columns for a backend prompt-based row.
+
+    The live ``agents`` table is prompt-based — ``prompt`` is
+    ``{system_prompt, variables:[{name,…}]}`` and skills arrive hydrated from the
+    ``_AgentSkills`` join. The old ``engine``/``trigger_type`` columns this listing
+    used to print no longer exist on the row, so they are gone from the table.
+    """
+    prompt = row.get("prompt") or {}
+    pvars = prompt.get("variables", []) if isinstance(prompt, dict) else []
+    names = [v.get("name") for v in pvars if isinstance(v, dict) and v.get("name")]
+    skills = [s.get("name") for s in (row.get("skills") or []) if isinstance(s, dict)]
+    return ",".join(n for n in names if n), ",".join(s for s in skills if s)
+
+
 def _agent_list() -> None:
+    """`agentos agent list` — every agent this user can reach.
+
+    The BACKEND is the source of truth for personal agents: they are authored in the
+    web app and stored as ``agents`` rows owned by the caller
+    (``relation_type='User'``, ``relation_id=<the caller's users.id>``), read via
+    GET /api/v1/agents. Local ``~/.agentos/agents/*.yaml`` manifests are still
+    listed — legacy/hand-written ones keep working — but they are no longer the
+    only source: since agent creation moved to the web app nothing writes that
+    directory, so listing it alone showed every user an empty table even when they
+    owned agents server-side.
+    """
     from sdk.agents.manifest import load_agents
     from sdk.client import BackendClient
 
     manifests = load_agents()
 
-    statuses: dict[str, str] = {}
+    custom_rows: list[dict] = []
     dept_rows: list[dict] = []
-    try:
-        client = BackendClient.from_config()
-        remote = asyncio.run(client.list_custom_agents())
-        for item in remote or []:
-            if isinstance(item, dict):
-                nm, st = item.get("name"), item.get("status", "")
-            else:
-                nm, st = getattr(item, "name", None), getattr(item, "status", "")
-            if nm:
-                statuses[nm] = st or ""
-        dept_rows = asyncio.run(client.list_department_agents())
-    except Exception as exc:  # noqa: BLE001 — backend status is best-effort for `list`
-        print(f"warning: could not fetch backend status ({exc})", file=sys.stderr)
-
-    if not manifests and not dept_rows:
-        print("no local agents found in ~/.agentos/agents/, and no department "
-              "default agents returned by the backend")
-        return
-
-    print(f"{'NAME':<24}{'ENGINE':<16}{'TRIGGER':<16}{'SOURCE':<12}{'STATUS'}")
-    for m in manifests:
+    errors: list[str] = []
+    client = BackendClient.from_config()
+    for label, fetch in (("custom", client.list_custom_agents),
+                         ("department", client.list_department_agents)):
+        try:
+            rows = asyncio.run(fetch()) or []
+        except Exception as exc:  # noqa: BLE001 — one source failing must not hide the other
+            # str() is EMPTY on some httpx errors (ReadTimeout, ConnectTimeout), which
+            # would print a warning with no reason at all — name the class then.
+            errors.append(f"{label}: {str(exc) or type(exc).__name__}")
+            continue
+        if label == "custom":
+            custom_rows = [r for r in rows if isinstance(r, dict)]
+        else:
+            dept_rows = [r for r in rows if isinstance(r, dict)]
+
+    for err in errors:
+        print(f"warning: could not fetch {err}", file=sys.stderr)
+
+    # Local manifests that also exist server-side are the same agent — show once.
+    remote_names = {r.get("name") for r in custom_rows}
+    local_only = [m for m in manifests if m.name not in remote_names]
+
+    if not custom_rows and not dept_rows and not local_only:
+        print("no agents found: none owned by you on the backend, no department "
+              "defaults, and no local manifests in ~/.agentos/agents/")
+        if not errors:
+            print("(personal agents are created in the web app — they appear here "
+                  "once saved)")
+        return
+
+    print(f"{'NAME':<32}{'SOURCE':<12}{'STATUS':<10}{'VARIABLES':<24}SKILLS")
+    for source, rows in (("personal", custom_rows), ("department", dept_rows)):
+        for row in rows:
+            variables, skills = _agent_row_summary(row)
+            print(f"{str(row.get('name', ''))[:31]:<32}{source:<12}"
+                  f"{str(row.get('status', ''))[:9]:<10}{variables[:23]:<24}{skills}")
+    for m in local_only:
         trigger_type = m.trigger.type if m.trigger else ""
-        status = statuses.get(m.name, "-")
-        print(f"{m.name:<24}{m.engine:<16}{trigger_type:<16}{'personal':<12}{status}")
-    for row in dept_rows:
-        print(
-            f"{row.get('name', ''):<24}{row.get('engine', ''):<16}"
-            f"{row.get('trigger_type', ''):<16}{'department':<12}{row.get('status', '')}"
-        )
+        print(f"{m.name[:31]:<32}{'local':<12}{'-':<10}{trigger_type[:23]:<24}")
 
 
 def _agent_run_ticket(name: str, flags: list[str]) -> None:

{devops_bot_sdk-1.5.0 → devops_bot_sdk-1.6.4}/sdk/client.py

@@ -1372,12 +1372,25 @@ class BackendClient:
     # This client only lists/reads them and manages per-agent status/delete.
 
     async def list_custom_agents(self) -> list[dict]:
-        """GET /api/v1/agents — list registered custom agents."""
+        """GET /api/v1/agents — the caller's OWN custom agents.
+
+        The backend scopes these to ``agents`` rows whose owner is this caller
+        (``relation_type='User'``, ``relation_id`` = the ``users.id`` it resolves
+        from ``GET /ml-api/users/profile`` for the presented token), so the list is
+        per-user with nothing to pass in. Rows are prompt-based: ``prompt`` =
+        ``{system_prompt, variables:[…]}``, plus a hydrated ``skills`` list.
+
+        An empty list means "this user owns no agents" and nothing else — the
+        backend answers 401 when it cannot verify the identity behind the token and
+        404 when the endpoint is absent (``BackendFeatureMissing``), so a silent
+        empty is never a masked failure. Agents are authored in the web app; the SDK
+        is consume-only.
+        """
+        url = self._url("/api/v1/agents")
         async with httpx.AsyncClient(timeout=15.0) as client:
-            resp = await client.get(
-                self._url("/api/v1/agents"),
-                headers=self._headers,
-            )
+            resp = await client.get(url, headers=self._headers)
+        if resp.status_code == 404:
+            raise BackendFeatureMissing("Custom agents", url)
         _check_status(resp.status_code, self._base_url)
         return resp.json().get("agents", [])
 

{devops_bot_sdk-1.5.0 → devops_bot_sdk-1.6.4}/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.4}/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.4}/sdk/ui/api.py

@@ -499,12 +499,14 @@ async def product_agents(product_id: str = Query(...)) -> dict:
 
 @router.get("/agents", dependencies=[_auth])
 async def agents() -> dict:
-    """The caller's custom agents (``relation_type=person``) from the backend.
-
-    Backend is the source of truth — agents are authored in the web app and read
-    here via GET /api/v1/agents (prompt-based shape: prompt = {system_prompt,
-    variables:[…]}; skills = [{name,…}]). Best-effort: on backend error the list
-    is empty with an ``error`` string the UI can surface.
+    """The caller's own custom agents (``relation_type='User'``) from the backend.
+
+    Backend is the source of truth — agents are authored in the web app, owned by
+    the caller's ``users.id`` (which the backend resolves from the profile for the
+    presented token), and read here via GET /api/v1/agents (prompt-based shape:
+    prompt = {system_prompt, variables:[…]}; skills = [{name,…}]). Best-effort: on
+    backend error the list is empty with an ``error`` string the UI can surface, so
+    "you own none" stays distinguishable from "the call failed".
     """
     from sdk.client import BackendClient
     from sdk.exceptions import BackendFeatureMissing
@@ -544,11 +546,16 @@ async def agents_all(department_id: str = Query("")) -> dict:
     """Every agent a person can pick to chat: their custom agents + department
     defaults, both read from the backend (source of truth).
 
-    Custom agents (``relation_type=person``) come from GET /api/v1/agents; defaults
-    (``relation_type=department`` + org-wide common) from GET /api/v1/department-agents.
-    Custom wins on a name collision. Each entry carries its detected variables so
-    the UI can render input fields. Both are best-effort — an unreachable backend
-    yields an empty list plus an error string rather than a hard failure.
+    The caller's own custom agents (``relation_type='User'``, owned by their
+    ``users.id``) come from GET /api/v1/agents; defaults (``relation_type='Department'``
+    + org-wide common) from GET /api/v1/department-agents. Custom wins on a name
+    collision. Each entry carries its detected variables so the UI can render input
+    fields.
+
+    Both sources are independent and best-effort: one failing never empties the
+    other, and each reports its own reason (``custom_error`` / ``defaults_error``)
+    so the picker can say WHY it is empty instead of just "(no agents installed)".
+    An empty ``agents`` with no error means the user genuinely owns none yet.
     """
     from sdk.client import BackendClient
     from sdk.exceptions import BackendFeatureMissing
@@ -556,41 +563,52 @@ async def agents_all(department_id: str = Query("")) -> dict:
     out: list[dict] = []
     seen: set[str] = set()
     dept = department_id
+    custom_error = ""
     defaults_error = ""
 
     try:
         client = BackendClient.from_config()
-        if not dept:
+    except Exception as exc:  # noqa: BLE001 — not configured / no token
+        return {"agents": [], "department_id": dept,
+                "custom_error": str(exc), "defaults_error": str(exc)}
+
+    if not dept:
+        try:
             profile = await client.bootstrap()
             dept = getattr(profile, "department_id", None) or ""
+        except Exception:  # noqa: BLE001 — the department label is cosmetic here
+            dept = ""
 
-        # Custom agents first so they win any name collision with a default.
-        try:
-            for r in await client.list_custom_agents():
-                nm = r.get("name")
-                if not nm or nm in seen:
-                    continue
-                seen.add(nm)
-                out.append(_flat_agent(r, "custom", chattable=True))
-        except BackendFeatureMissing:
-            defaults_error = ("Custom agents aren't available on this backend — "
-                              "it may be running an older version.")
-
-        # Department defaults (a default must be activated/cloned before it runs).
-        try:
-            for r in await client.list_department_agents():
-                nm = r.get("name")
-                if not nm or nm in seen:
-                    continue
-                seen.add(nm)
-                out.append(_flat_agent(r, "default", chattable=False, department_id=dept))
-        except BackendFeatureMissing:
-            defaults_error = ("Department default agents aren't available on this "
-                              "backend — it may be running an older version.")
-    except Exception:  # noqa: BLE001 — best-effort; return whatever we gathered
-        pass
+    # Custom agents first so they win any name collision with a default.
+    try:
+        for r in await client.list_custom_agents():
+            nm = r.get("name")
+            if not nm or nm in seen:
+                continue
+            seen.add(nm)
+            out.append(_flat_agent(r, "custom", chattable=True))
+    except BackendFeatureMissing:
+        custom_error = ("Custom agents aren't available on this backend — "
+                        "it may be running an older version.")
+    except Exception as exc:  # noqa: BLE001 — surface it; don't hide it as "none"
+        custom_error = f"Couldn't load your agents: {exc}"
+
+    # Department defaults (a default must be activated/cloned before it runs).
+    try:
+        for r in await client.list_department_agents():
+            nm = r.get("name")
+            if not nm or nm in seen:
+                continue
+            seen.add(nm)
+            out.append(_flat_agent(r, "default", chattable=False, department_id=dept))
+    except BackendFeatureMissing:
+        defaults_error = ("Department default agents aren't available on this "
+                          "backend — it may be running an older version.")
+    except Exception as exc:  # noqa: BLE001
+        defaults_error = f"Couldn't load department defaults: {exc}"
 
-    return {"agents": out, "department_id": dept, "defaults_error": defaults_error}
+    return {"agents": out, "department_id": dept,
+            "custom_error": custom_error, "defaults_error": defaults_error}
 
 
 @router.get("/profile", dependencies=[_auth])

{devops_bot_sdk-1.5.0 → devops_bot_sdk-1.6.4}/sdk/ui/static/app.js

@@ -605,10 +605,17 @@
         const custom = [], deflt = [];
         (d.agents || []).forEach(a => { agents[a.name] = a; (a.source === "default" ? deflt : custom).push(a); });
         const opt = a => `<option value="${esc(a.name)}">${esc(a.name)}${a.variables && a.variables.length ? " · " + a.variables.length + " input(s)" : ""}${a.source === "default" ? " (department)" : ""}</option>`;
+        // An empty picker has two very different causes — say which. A load error
+        // must never read as "you have no agents"; agents live in the web app, so
+        // the genuinely-empty case points the user there.
+        const emptyLabel = d.custom_error
+          ? "(couldn't load your agents — see the message below)"
+          : "(no agents yet — create one in the web app)";
         $("agent-pick").innerHTML =
           (custom.length ? `<optgroup label="Your agents">${custom.map(opt).join("")}</optgroup>` : "") +
           (deflt.length ? `<optgroup label="Department defaults">${deflt.map(opt).join("")}</optgroup>` : "") ||
-          `<option value="">(no agents installed)</option>`;
+          `<option value="">${esc(emptyLabel)}</option>`;
+        if (d.custom_error) toast(d.custom_error, "err");
         // Deep-link support: /agents.html?agent=NAME preselects that agent.
         const want = new URLSearchParams(location.search).get("agent");
         if (want && agents[want]) $("agent-pick").value = want;

devops_bot_sdk-1.6.4/tests/test_agent_listing.py

@@ -0,0 +1,170 @@
+"""Listing the agents a person actually has — CLI and control panel.
+
+The bug this covers: `agentos agent list` listed only local
+``~/.agentos/agents/*.yaml`` manifests as "personal", but nothing writes that
+directory since agent creation moved to the web app — so every user saw an empty
+table while owning agents server-side. The BACKEND is the source of truth
+(``GET /api/v1/agents``, scoped to the caller's own ``users.id``), and a fetch
+FAILURE must never be rendered as "you have no agents".
+
+Covers:
+  * ``sdk.cli._agent_list`` — backend rows are the personal source; local-only
+    manifests still show; one source failing does not hide the other.
+  * ``sdk.client.BackendClient.list_custom_agents`` — 404 → BackendFeatureMissing.
+  * ``GET /api/ui/agents/all`` — per-source error strings (custom vs defaults).
+"""
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from sdk import cli
+
+
+def _row(name, *, variables=(), skills=(), status="active"):
+    """A backend prompt-based ``agents`` row (docs/DATABASE_SCHEMA.md §4)."""
+    return {
+        "id": f"id-{name}", "name": name, "status": status,
+        "relation_type": "User", "relation_id": "0c2fa9fe-5707-420c-89c6-a36a11a4bcc3",
+        "prompt": {"system_prompt": "do things", "variables": [{"name": v} for v in variables]},
+        "skills": [{"name": s} for s in skills],
+    }
+
+
+class TestAgentListCli:
+    def _run(self, capsys, *, custom, dept, manifests=()):
+        client = SimpleNamespace(
+            list_custom_agents=AsyncMock(**custom),
+            list_department_agents=AsyncMock(**dept),
+        )
+        with patch("sdk.agents.manifest.load_agents", return_value=list(manifests)), \
+             patch("sdk.client.BackendClient.from_config", return_value=client):
+            cli._agent_list()
+        return capsys.readouterr()
+
+    def test_backend_agents_are_listed_as_personal(self, capsys):
+        """The whole point: web-app-authored agents appear with no local files."""
+        out = self._run(
+            capsys,
+            custom={"return_value": [_row("My Research Agent", variables=["topic"],
+                                          skills=["web-search"])]},
+            dept={"return_value": [_row("AI Engineer")]},
+        )
+        assert "My Research Agent" in out.out
+        assert "personal" in out.out
+        assert "topic" in out.out and "web-search" in out.out
+        assert "AI Engineer" in out.out and "department" in out.out
+
+    def test_local_manifest_also_on_the_backend_is_listed_once(self, capsys):
+        manifest = SimpleNamespace(name="My Research Agent", engine="claude_code",
+                                   trigger=SimpleNamespace(type="schedule"))
+        out = self._run(capsys, custom={"return_value": [_row("My Research Agent")]},
+                        dept={"return_value": []}, manifests=[manifest])
+        assert out.out.count("My Research Agent") == 1
+        assert "local" not in out.out
+
+    def test_local_only_manifest_still_shows(self, capsys):
+        manifest = SimpleNamespace(name="legacy-agent", engine="claude_code",
+                                   trigger=SimpleNamespace(type="schedule"))
+        out = self._run(capsys, custom={"return_value": []}, dept={"return_value": []},
+                        manifests=[manifest])
+        assert "legacy-agent" in out.out and "local" in out.out
+
+    def test_owning_none_says_so_without_an_error(self, capsys):
+        out = self._run(capsys, custom={"return_value": []}, dept={"return_value": []})
+        assert "no agents found" in out.out
+        assert "web app" in out.out          # points the user where agents are made
+        assert "warning" not in out.err
+
+    def test_custom_failure_is_a_warning_and_does_not_hide_defaults(self, capsys):
+        out = self._run(capsys, custom={"side_effect": RuntimeError("boom")},
+                        dept={"return_value": [_row("AI Engineer")]})
+        assert "could not fetch custom: boom" in out.err
+        assert "AI Engineer" in out.out, "one source failing must not empty the other"
+
+    def test_blank_exception_message_still_names_the_failure(self, capsys):
+        """httpx.ReadTimeout stringifies to "" — a reasonless warning is useless."""
+        class ReadTimeout(Exception):
+            def __str__(self):
+                return ""
+        out = self._run(capsys, custom={"side_effect": ReadTimeout()},
+                        dept={"return_value": []})
+        assert "could not fetch custom: ReadTimeout" in out.err
+
+
+class TestListCustomAgentsClient:
+    @pytest.mark.asyncio
+    async def test_404_raises_backend_feature_missing(self):
+        """Parity with list_department_agents — an absent endpoint is not "no agents"."""
+        from sdk.client import BackendClient
+        from sdk.exceptions import BackendFeatureMissing
+
+        client = BackendClient(base_url="http://be", token="co_x_y")
+        resp = SimpleNamespace(status_code=404, json=lambda: {})
+        http = AsyncMock()
+        http.get = AsyncMock(return_value=resp)
+        http.__aenter__ = AsyncMock(return_value=http)
+        http.__aexit__ = AsyncMock(return_value=False)
+        with patch("sdk.client.httpx.AsyncClient", return_value=http):
+            with pytest.raises(BackendFeatureMissing):
+                await client.list_custom_agents()
+
+    @pytest.mark.asyncio
+    async def test_200_returns_rows(self):
+        from sdk.client import BackendClient
+
+        client = BackendClient(base_url="http://be", token="co_x_y")
+        rows = [_row("a")]
+        resp = SimpleNamespace(status_code=200, json=lambda: {"agents": rows})
+        http = AsyncMock()
+        http.get = AsyncMock(return_value=resp)
+        http.__aenter__ = AsyncMock(return_value=http)
+        http.__aexit__ = AsyncMock(return_value=False)
+        with patch("sdk.client.httpx.AsyncClient", return_value=http):
+            assert await client.list_custom_agents() == rows
+
+
+class TestUiAgentsAll:
+    @pytest.mark.asyncio
+    async def test_reports_custom_and_default_errors_separately(self):
+        from sdk.ui import api
+
+        client = SimpleNamespace(
+            list_custom_agents=AsyncMock(side_effect=RuntimeError("custom down")),
+            list_department_agents=AsyncMock(return_value=[_row("AI Engineer")]),
+            bootstrap=AsyncMock(return_value=SimpleNamespace(department_id="d-1")),
+        )
+        with patch("sdk.client.BackendClient.from_config", return_value=client):
+            out = await api.agents_all(department_id="d-1")
+        assert "custom down" in out["custom_error"]
+        assert out["defaults_error"] == ""
+        assert [a["name"] for a in out["agents"]] == ["AI Engineer"]
+
+    @pytest.mark.asyncio
+    async def test_no_errors_when_the_user_simply_owns_none(self):
+        from sdk.ui import api
+
+        client = SimpleNamespace(
+            list_custom_agents=AsyncMock(return_value=[]),
+            list_department_agents=AsyncMock(return_value=[]),
+            bootstrap=AsyncMock(return_value=SimpleNamespace(department_id="d-1")),
+        )
+        with patch("sdk.client.BackendClient.from_config", return_value=client):
+            out = await api.agents_all(department_id="d-1")
+        assert out == {"agents": [], "department_id": "d-1",
+                       "custom_error": "", "defaults_error": ""}
+
+    @pytest.mark.asyncio
+    async def test_custom_wins_a_name_collision_with_a_default(self):
+        from sdk.ui import api
+
+        client = SimpleNamespace(
+            list_custom_agents=AsyncMock(return_value=[_row("Shared")]),
+            list_department_agents=AsyncMock(return_value=[_row("Shared")]),
+            bootstrap=AsyncMock(return_value=SimpleNamespace(department_id="d-1")),
+        )
+        with patch("sdk.client.BackendClient.from_config", return_value=client):
+            out = await api.agents_all(department_id="d-1")
+        assert [(a["name"], a["source"]) for a in out["agents"]] == [("Shared", "custom")]

{devops_bot_sdk-1.5.0 → devops_bot_sdk-1.6.4}/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")