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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.158
+Version: 1.5.0
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary
@@ -20,6 +20,7 @@ Requires-Dist: psutil>=5.9; extra == "process"
 Provides-Extra: ui
 Requires-Dist: fastapi>=0.110; extra == "ui"
 Requires-Dist: uvicorn>=0.29; extra == "ui"
+Requires-Dist: psutil>=5.9; extra == "ui"
 Provides-Extra: all
 Requires-Dist: Pillow>=10.0; extra == "all"
 Requires-Dist: psutil>=5.9; extra == "all"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.158
+Version: 1.5.0
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary
@@ -20,6 +20,7 @@ Requires-Dist: psutil>=5.9; extra == "process"
 Provides-Extra: ui
 Requires-Dist: fastapi>=0.110; extra == "ui"
 Requires-Dist: uvicorn>=0.29; extra == "ui"
+Requires-Dist: psutil>=5.9; extra == "ui"
 Provides-Extra: all
 Requires-Dist: Pillow>=10.0; extra == "all"
 Requires-Dist: psutil>=5.9; extra == "all"

{devops_bot_sdk-1.4.158 → devops_bot_sdk-1.5.0}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ sdk/config.py
 sdk/crucial.py
 sdk/exceptions.py
 sdk/git_ops.py
+sdk/github_ingest.py
 sdk/graphify.py
 sdk/local_exec.py
 sdk/platform_compat.py
@@ -23,7 +24,9 @@ sdk/sse.py
 sdk/test.py
 sdk/test_pipeline.py
 sdk/updater.py
+sdk/vps_health.py
 sdk/agents/__init__.py
+sdk/agents/activity.py
 sdk/agents/builder.py
 sdk/agents/chat.py
 sdk/agents/connectors.py
@@ -88,12 +91,15 @@ sdk/ui/static/runs.html
 sdk/ui/static/setup.html
 sdk/ui/static/styles.css
 sdk/ui/static/tickets.html
+tests/test_agent_activity.py
 tests/test_agent_chat_features.py
 tests/test_agent_prompt_async.py
 tests/test_agent_prompt_models.py
 tests/test_agent_run_ticket.py
 tests/test_agents_connectors_builder.py
 tests/test_git_action.py
+tests/test_github_ingest.py
 tests/test_health.py
 tests/test_otp_login.py
-tests/test_updater_extras.py
+tests/test_updater_extras.py
+tests/test_vps_health.py

{devops_bot_sdk-1.4.158 → devops_bot_sdk-1.5.0}/devops_bot_sdk.egg-info/requires.txt

@@ -19,3 +19,4 @@ Pillow>=10.0
 [ui]
 fastapi>=0.110
 uvicorn>=0.29
+psutil>=5.9

{devops_bot_sdk-1.4.158 → devops_bot_sdk-1.5.0}/pyproject.toml

@@ -31,6 +31,11 @@ process = [
 ui = [
     "fastapi>=0.110",       # sdk/ui — control-panel web app
     "uvicorn>=0.29",        # ASGI server for `agentos-ui`
+    "psutil>=5.9",          # sdk/ui/health.py — CPU/RAM/disk/uptime for GET /api/ui/health
+                            # AND the 2-hourly allocation PATCH (sdk/vps_health.py). The
+                            # bootstrap installs `[ui]` only, so without it here every
+                            # VPS reports "resources.available: False" and the health
+                            # cron can only send status + IP.
 ]
 all = [
     "Pillow>=10.0",

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

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.4.154
+Version: 1.5.0
 
 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.4.158"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.5.0"   # 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.4.158 → devops_bot_sdk-1.5.0}/sdk/agentd.py

@@ -85,6 +85,7 @@ from typing import TYPE_CHECKING, Any
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from apscheduler.triggers.cron import CronTrigger
 
+from sdk.agents import activity
 from sdk.client import BackendClient
 from sdk.models.requests import OrchestrateRequest
 
@@ -354,6 +355,9 @@ async def _dispatch_agent_run(
 
     policy = manifest.approval.policy
     handled: set[str] = set()  # session/task ids already round-tripped by this dispatch
+    # How this run was triggered — carried into the `agent_activities` line so the
+    # feed distinguishes a cron firing from a ticket trigger from a human "Run".
+    _activity_kind = "run-ticket" if auto_approve else ("ticket_label" if task else "scheduled")
 
     async def _on_status_update(status: str, state: dict) -> None:
         if status != "awaiting_approval":
@@ -402,11 +406,21 @@ async def _dispatch_agent_run(
             async def _tee(ev: dict) -> None:
                 run_log.log_event(_log_path, ev)
 
+            _started = time.monotonic()
             local_result = await claude_code_engine.run(
                 manifest, skill_text, mcp_config, extra_env=effective_secrets or None,
                 on_event=_tee,
             )
             run_log.finish_run(_log_path, local_result)
+            # Local ledger + platform `agent_activities` feed. EVERY trigger path
+            # reaches this function (cron schedule, ticket label, on-demand
+            # run-on-ticket from the UI / CLI / desktop IPC), so a VPS agent run is
+            # recorded exactly once regardless of origin — see sdk.agents.activity.
+            await activity.record_run(
+                manifest.name, _activity_kind, local_result,
+                time.monotonic() - _started, client=client,
+                detail=f"task {task_id}" if task_id else "",
+            )
             outcome.update({
                 "task_id": task_id,
                 "result": local_result.get("result", ""),
@@ -418,6 +432,10 @@ async def _dispatch_agent_run(
                 manifest.name, task_id, exc,
             )
             outcome["error"] = str(exc)
+            await activity.record_run(
+                manifest.name, _activity_kind, {"ok": False, "error": str(exc)},
+                0.0, client=client, detail=f"task {task_id}" if task_id else "",
+            )
             return
 
         # FINALIZE — same field names sdk.local_exec.run_claude_local's result

devops_bot_sdk-1.5.0/sdk/agents/activity.py

@@ -0,0 +1,110 @@
+"""Agent-activity reporting — the ONE place a custom / department agent run is
+recorded, for both sinks:
+
+  * the LOCAL usage ledger (``sdk.agents.usage`` → ``~/.agentos/usage.jsonl``),
+    which backs ``GET /api/ui/agents/usage`` and, through it, the AI backend
+    report's "VPS Agent Logs" section, and
+  * the PLATFORM activity feed — ``POST {ML_GATEWAY}/ml-api/agent-activity``
+    with ``{activity, agentId}``, which the ML backend writes into the Postgres
+    ``agent_activities`` table (docs/DATABASE_SCHEMA.md #3: ``user_id``,
+    ``activity``, ``agent_id``) and the AI backend reads back RBAC-scoped for
+    reporting + chat.
+
+Every VPS-side agent run goes through here no matter how it was triggered — the
+control panel (chat / run / run-on-ticket), an ``agentd`` cron schedule, an
+``agentd`` ticket-label trigger, the CLI, or the desktop IPC bridge. Before this
+module only the control-panel paths emitted, so scheduled and ticket-triggered
+runs never reached ``agent_activities``.
+
+``agent_activities.agent_id`` is an FK onto ``agents.id``, so only agents that
+exist in the BACKEND emit — ``BackendClient.resolve_agent_id`` returns None for
+a local-only manifest and the emit is skipped (the local ledger still records
+it). Both custom and department-default agents resolve, so both are tracked.
+
+Best-effort throughout: nothing in here raises into a run.
+"""
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:  # pragma: no cover — typing only
+    from sdk.client import BackendClient
+
+logger = logging.getLogger("sdk.agents.activity")
+
+# How a run reached us → the verb that opens the activity line. Keep these short:
+# the feed is rendered as one line per row in reports and in chat answers.
+_VERB = {
+    "chat": "Chatted with",
+    "run": "Ran",
+    "run-ticket": "Ran",
+    "scheduled": "Ran (schedule)",
+    "ticket_label": "Ran (ticket trigger)",
+    "cli": "Ran (cli)",
+}
+
+
+def describe(name: str, kind: str, result: dict | None, duration_s: float = 0.0,
+             detail: str = "") -> str:
+    """The human-readable ``activity`` string stored in ``agent_activities``."""
+    res = result or {}
+    verb = _VERB.get(kind, "Ran")
+    status = "ok" if res.get("ok") else "error"
+    line = f"{verb} agent '{name}' — {status}"
+    if duration_s:
+        line += f" ({round(float(duration_s), 1)}s)"
+    err = str(res.get("error") or "").strip()
+    if status == "error" and err:
+        line += f": {err[:200]}"
+    if detail:
+        line += f" — {detail}"
+    return line
+
+
+async def emit(name: str, kind: str, result: dict | None, duration_s: float = 0.0,
+               *, client: "BackendClient | None" = None, detail: str = "") -> bool:
+    """Emit ONE ``{activity, agentId}`` event for a finished agent run.
+
+    Returns True when the webhook accepted it, False otherwise (unknown agent,
+    no token, backend down) — never raises.
+    """
+    try:
+        if client is None:
+            from sdk.client import BackendClient
+            client = BackendClient.from_config()
+        agent_id = await client.resolve_agent_id(name)
+        if not agent_id:                       # local-only agent → not tracked
+            return False
+        return await client.log_agent_activity(
+            describe(name, kind, result, duration_s, detail), agent_id,
+        )
+    except Exception as exc:  # noqa: BLE001 — activity emit must never break a run
+        logger.debug("activity emit failed agent=%s err=%s", name, exc)
+        return False
+
+
+async def record_run(name: str, kind: str, result: dict | None, duration_s: float = 0.0,
+                     *, client: "BackendClient | None" = None, detail: str = "") -> None:
+    """Record a finished run to BOTH sinks: local ledger, then platform feed.
+
+    The ledger write happens first and independently of the webhook, so a
+    backend outage still leaves per-agent utilisation on the VPS (which is what
+    ``/api/ui/agents/usage`` and the report's "VPS Agent Logs" read).
+    """
+    res: dict[str, Any] = result or {}
+    try:
+        from sdk.agents import usage as usage_mod
+        usage_mod.record(
+            name,
+            kind=kind,
+            duration_s=duration_s,
+            input_tokens=res.get("input_tokens", 0) or 0,
+            output_tokens=res.get("output_tokens", 0) or 0,
+            cost_usd=res.get("cost_usd", 0.0) or 0.0,
+            ok=bool(res.get("ok")),
+        )
+    except Exception as exc:  # noqa: BLE001 — ledger write must never break a run
+        logger.debug("activity ledger write failed agent=%s err=%s", name, exc)
+
+    await emit(name, kind, res, duration_s, client=client, detail=detail)

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

@@ -96,12 +96,16 @@ def main() -> None:
         _default_agents_command(rest)
         return
 
+    if noun == "github":
+        _github_command(rest)
+        return
+
     _print_usage()
     sys.exit(1)
 
 
 def _print_usage() -> None:
-    print("usage: agentos <configure|agent|integration|default-agents|agentd> ...")
+    print("usage: agentos <configure|agent|integration|default-agents|agentd|github> ...")
     print()
     print("  agentos configure [--rotate]")
     print("  agentos agent <list|run NAME|chat NAME MSG|logs NAME|enable NAME|disable NAME|rm NAME>")
@@ -109,6 +113,7 @@ def _print_usage() -> None:
     print("  agentos integration <add PATH|test NAME|list|rm NAME>")
     print("  agentos default-agents list [--department-id UUID]   # read-only; agents are created in the web app")
     print("  agentos agentd <start [--foreground]|status>")
+    print("  agentos github <ingest [--days N]|status>            # PR ingestion; --days N backfills N days")
 
 
 # ── agent ────────────────────────────────────────────────────────────────
@@ -167,10 +172,21 @@ def _agent_command(args: list[str]) -> None:
 
 
 def _agent_chat(name: str, message: str) -> None:
+    import time as _time
+
+    from sdk.agents import activity
     from sdk.agents.chat import chat_with_agent
 
+    async def _run() -> dict:
+        started = _time.monotonic()
+        res = await chat_with_agent(name, message)
+        # Same two sinks as the control panel: local usage ledger + the platform
+        # `agent_activities` feed. A CLI chat is as much an agent run as a UI one.
+        await activity.record_run(name, "chat", res, _time.monotonic() - started)
+        return res
+
     try:
-        result = asyncio.run(chat_with_agent(name, message))
+        result = asyncio.run(_run())
     except LookupError as exc:
         print(f"error: {exc}")
         sys.exit(1)
@@ -579,5 +595,60 @@ def _agentd_command(args: list[str]) -> None:
     sys.exit(1)
 
 
+# ── github ───────────────────────────────────────────────────────────────
+
+def _github_command(args: list[str]) -> None:
+    """`agentos github ingest [--days N]` / `agentos github status`.
+
+    The daily ingestion normally runs by itself inside `agentos-ui` (see
+    sdk.github_ingest). This is the manual handle: `ingest` runs one now,
+    `--days N` forces an N-day window — that is the backfill.
+    """
+    from sdk import github_ingest as gi
+
+    verb = args[0] if args else None
+
+    if verb == "status":
+        st = gi.status()
+        state = st.get("state") or {}
+        print(f"enabled        : {st['enabled']}")
+        print(f"daily slot     : {st['slot_utc']} UTC")
+        print(f"catch-up cap   : {st['lookback_days']} days")
+        print(f"first-run seed : {st['backfill_days']} days"
+              f"{'' if st['backfilled'] else '  ← not run yet; the next run backfills'}")
+        print(f"last success   : {state.get('last_success_at') or '(never)'}")
+        print(f"last status    : {state.get('last_status') or '(none)'}")
+        if state.get("last_job_id"):
+            print(f"last job       : {state['last_job_id']}  {state.get('last_status_url', '')}")
+        if state.get("last_error"):
+            print(f"last error     : {state['last_error']}")
+        return
+
+    if verb == "ingest":
+        days = None
+        if "--days" in args:
+            try:
+                days = int(args[args.index("--days") + 1])
+            except (IndexError, ValueError):
+                print("error: --days needs a whole number of days, e.g. --days 50")
+                sys.exit(1)
+        result = asyncio.run(gi.run_once(days=days))
+        status = result.get("status")
+        if status == "queued":
+            print(f"queued: PRs since {result['since']}  job_id={result.get('job_id') or '(none)'}")
+            if result.get("status_url"):
+                print(f"poll  : {result['status_url']}  (on the AI backend)")
+            return
+        if status == "no_github_link":
+            print("nothing to do: this account has no GitHub connected.")
+            return
+        print(f"failed: {result.get('reason') or 'unknown error'}")
+        sys.exit(1)
+
+    print("usage: agentos github ingest [--days N]   # N-day backfill; omit for the normal window")
+    print("       agentos github status")
+    sys.exit(1)
+
+
 if __name__ == "__main__":
     main()

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

@@ -763,13 +763,18 @@ class BackendClient:
         except Exception:
             return "pending"
 
-    async def github_token(self) -> str | None:
-        """GET /ml-api/github/token → the user's GitHub access token (gho_…).
-
-        Used by the LOCAL agent to authenticate git/gh for clone/push/PR. The
-        endpoint lives on the ML backend (devopsbot-be), authorised by the same
-        co_ token. Best-effort: returns None on any failure so a run without a
-        connected GitHub account still proceeds (clone/PR steps just won't auth).
+    async def github_token_record(self) -> dict | None:
+        """GET /ml-api/github/token → the caller's WHOLE GitHub link record.
+
+        Returns the ``data`` object — ``{id, userId, githubId, username,
+        accessToken, scope, …}`` — or None when this user has no GitHub link, the
+        token is rejected, or the backend is unreachable. Inherently per-user: the
+        ML backend resolves WHICH link to return from the ``co_`` token, so there
+        is no list-all form.
+
+        ``github_token()`` below is the accessToken-only view of this. The daily
+        PR-ingest cron (``sdk.github_ingest``) needs ``username`` too, which is why
+        the full record is exposed. Best-effort — never raises.
         """
         from sdk.config import BE_DEFAULT_URL
 
@@ -785,9 +790,72 @@ class BackendClient:
                 resp = await client.get(url, headers=headers)
             if resp.status_code >= 400:
                 return None
-            data = (resp.json() or {}).get("data") or {}
-            return data.get("accessToken") or None
-        except Exception:
+            return (resp.json() or {}).get("data") or None
+        except Exception:  # noqa: BLE001
+            return None
+
+    async def github_token(self) -> str | None:
+        """GET /ml-api/github/token → the user's GitHub access token (gho_…).
+
+        Used by the LOCAL agent to authenticate git/gh for clone/push/PR. The
+        endpoint lives on the ML backend (devopsbot-be), authorised by the same
+        co_ token. Best-effort: returns None on any failure so a run without a
+        connected GitHub account still proceeds (clone/PR steps just won't auth).
+        """
+        record = await self.github_token_record()
+        return (record or {}).get("accessToken") or None
+
+    async def ingest_github_prs(
+        self,
+        *,
+        github_username: str,
+        github_access_token: str,
+        since: str | None = None,
+        user_id: str = "",
+    ) -> dict | None:
+        """POST /api/v1/github/prs — queue PR ingestion for THIS user on the backend.
+
+        This is the daily GitHub ingestion trigger. It runs on the AI backend
+        (``devopsbot-ai.apiswagger.co.uk`` — ``self._url``, the same base every other
+        ``/api/v1`` call uses), NOT the ML gateway: the backend owns the LLM
+        summarise, the downstream daily-summary forward, and the Qdrant upsert.
+        The SDK only decides WHEN, because only this machine knows this user's
+        schedule and its own last-success watermark.
+
+        ``since`` is an ISO date (``YYYY-MM-DD``) → the backend's
+        ``GetUserPRsRequest.date_from``. Omitted means "today", which is what a
+        never-missed daily run wants; ``sdk.github_ingest`` sends the catch-up
+        watermark instead so a machine that was off does not silently lose days.
+
+        The credentials are sent in the body because that is what the endpoint
+        accepts today. The ``Authorization: co_`` header goes with every request
+        regardless, so once the backend resolves the GitHub link server-side from
+        that token (see docs/GITHUB_SCHEDULING_SDK_MIGRATION.md §3 step 1) it can
+        ignore the body fields without breaking this client.
+
+        Returns the response JSON (``{job_id, …}``) or None on any failure —
+        never raises into the cron.
+        """
+        payload = [{
+            "userId": user_id or self._user_id_from_token(),
+            "githubUsername": github_username,
+            "githubAccessToken": github_access_token,
+            "apiTokenHash": self._token,   # downstream daily-summary Authorization
+        }]
+        if since:
+            payload[0]["date_from"] = since
+        try:
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                resp = await client.post(
+                    self._url("/api/v1/github/prs"), json=payload, headers=self._headers,
+                )
+            if resp.status_code >= 400:
+                logger.warning("client.ingest_github_prs failed status=%s body=%s",
+                               resp.status_code, resp.text[:200])
+                return None
+            return resp.json()
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.ingest_github_prs error err=%s", exc)
             return None
 
     async def move_to_backlog(self, task_id: str) -> bool:
@@ -1093,6 +1161,35 @@ class BackendClient:
         _AGENT_ID_CACHE[nm] = ""     # negative-cache: not a backend agent
         return None
 
+    async def report_vps_allocation(self, payload: dict) -> bool:
+        """PATCH ``{ML_GATEWAY_URL}/ml-api/contabo/allocation`` — this machine's health.
+
+        The allocation row is resolved SERVER-side from the ``co_`` token (one row
+        per user — ``contabo_allocation``, docs/DATABASE_SCHEMA.md #18), so the body
+        carries metrics only: ``status``, ``cpuUsage``, ``ramUsage``, ``usedRam``,
+        ``totalRam``, ``diskUsage``, ``totalDisk``, ``bandwidthUsed``, ``ipAddress``,
+        ``uptimeSeconds``, ``lastPingedAt``.
+
+        Driven by the SDK-side health cron (``sdk.vps_health``) — deliberately NOT by
+        the AI backend, so VPS liveness reporting does not depend on that service.
+        Best-effort: never raises; a failed ping is logged and the next tick retries.
+        """
+        from sdk.config import ML_GATEWAY_URL
+
+        url = f"{ML_GATEWAY_URL.rstrip('/')}/ml-api/contabo/allocation"
+        headers = {**self._headers, "accept": "*/*", "developer-name": "null", "product": ""}
+        try:
+            async with httpx.AsyncClient(timeout=20.0) as client:
+                resp = await client.patch(url, json=payload, headers=headers)
+            if resp.status_code >= 400:
+                logger.warning("client.report_vps_allocation failed status=%s body=%s",
+                               resp.status_code, resp.text[:200])
+                return False
+            return True
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.report_vps_allocation error err=%s", exc)
+            return False
+
     async def notify_whatsapp(
         self,
         task_id: str,