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

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

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

@@ -23,7 +23,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,6 +90,7 @@ 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
@@ -96,4 +99,5 @@ tests/test_agents_connectors_builder.py
 tests/test_git_action.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.4.159}/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.4.159}/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.4.159}/sdk/__init__.py

@@ -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.4.159"   # 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.4.159}/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.4.159/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.4.159}/sdk/cli.py

@@ -167,10 +167,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)

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

@@ -1093,6 +1093,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,

{devops_bot_sdk-1.4.158 → devops_bot_sdk-1.4.159}/sdk/ui/api.py

@@ -180,6 +180,33 @@ async def health() -> dict:
     return collect_health()
 
 
+@router.get("/vps/allocation", dependencies=[_auth])
+async def vps_allocation_status() -> dict:
+    """State of the SDK-side health cron: enabled?, interval, last ping attempt.
+
+    The cron (``sdk.vps_health``, started by this server's lifespan) PATCHes
+    ``/ml-api/contabo/allocation`` every 2h. This is the read-only view of it —
+    useful when a ``contabo_allocation`` row looks stale.
+    """
+    from sdk import vps_health
+
+    return vps_health.last_report()
+
+
+@router.post("/vps/allocation/report", dependencies=[_auth])
+async def vps_allocation_report() -> dict:
+    """Force ONE health ping now (out of band from the 2h cron) and report the result.
+
+    Same payload the cron sends — for QA / first-boot verification without waiting
+    two hours. Returns ``{ok, payload}``; ``ok=False`` on a rejected or unreachable
+    PATCH (the reason is in ``GET /vps/allocation``).
+    """
+    from sdk import vps_health
+
+    ok = await vps_health.report_once()
+    return {"ok": ok, **vps_health.last_report()}
+
+
 # ── IP allowlist management ─────────────────────────────────────────────────
 # Whitelist a client IP for THIS SDK. A whitelisted IP passes the IP gate for
 # EVERY path (all /api/ui/* endpoints + the UI + /docs); data endpoints still
@@ -379,23 +406,19 @@ async def logs_stream() -> StreamingResponse:
 # ── Agent-activity webhook ──────────────────────────────────────────────────
 # Every custom/default agent run/chat records to the LOCAL usage ledger AND emits
 # a `{activity, agentId}` event to the ML gateway (POST /ml-api/agent-activity),
-# which stores it for RBAC-scoped reporting via the chat endpoint. Only agents that
-# exist in the backend (have an agentId) are emitted — local-only agents are skipped.
-# Best-effort: never raises into the run.
+# which stores it in Postgres `agent_activities` for RBAC-scoped reporting + chat.
+# Only agents that exist in the backend (have an agentId) are emitted — local-only
+# agents are ledger-only. Best-effort: never raises into the run.
+#
+# The composition + emit itself lives in `sdk.agents.activity` so the agentd
+# trigger paths (cron schedule, ticket label) report identically; this is a thin
+# wrapper kept for the panel's direct chat/run endpoints, which already write the
+# usage ledger themselves.
 
 async def _emit_agent_activity(name: str, kind: str, result: dict, duration_s: float = 0.0) -> None:
-    try:
-        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
-        verb = "Chatted with" if kind == "chat" else "Ran"
-        status = "ok" if result.get("ok") else "error"
-        detail = f" ({round(duration_s, 1)}s)" if duration_s else ""
-        await client.log_agent_activity(f"{verb} agent '{name}' — {status}{detail}", agent_id)
-    except Exception:  # noqa: BLE001 — activity emit must never break a run
-        pass
+    from sdk.agents import activity
+
+    await activity.emit(name, kind, result, duration_s)
 
 
 # ── Agents: catalog, creation, chat, default agents ────────────────────────
@@ -863,21 +886,17 @@ async def agent_run_ticket(body: AgentTicketRunRequest) -> dict:
     department_id = body.department_id
 
     async def work() -> dict:
-        import time as _time
-
         from sdk.agents import ticket_run
         from sdk.client import BackendClient
 
         client = BackendClient.from_config()
-        started = _time.monotonic()
         outcome = await ticket_run.run_on_ticket(
             client, name, ticket_key, scope=scope, department_id=department_id,
             variables=variables, secrets=secrets,
         )
-        await _emit_agent_activity(
-            name, "run-ticket", outcome if isinstance(outcome, dict) else {},
-            _time.monotonic() - started,
-        )
+        # No activity/ledger write here: this path runs through
+        # `agentd._dispatch_agent_run`, which records the run itself (kind
+        # "run-ticket") — emitting again would double-count it.
         return {"ticket_key": ticket_key, **(outcome if isinstance(outcome, dict) else {})}
 
     return {"job_id": jobs.start(work())}

{devops_bot_sdk-1.4.158 → devops_bot_sdk-1.4.159}/sdk/ui/server.py

@@ -23,6 +23,9 @@ _STATIC_DIR = Path(__file__).parent / "static"
 
 def create_app():
     """Build the FastAPI app (importable for tests)."""
+    import asyncio
+    import contextlib
+
     from fastapi import FastAPI, Request
     from fastapi.responses import FileResponse, RedirectResponse
     from fastapi.staticfiles import StaticFiles
@@ -31,12 +34,42 @@ def create_app():
     from sdk.ui.api import router as api_router
     from sdk.ui.ip_allowlist import IPAllowlistMiddleware
 
+    @contextlib.asynccontextmanager
+    async def lifespan(_app):
+        """Own the VPS health cron for the life of the server.
+
+        This process is the one thing that runs 24/7 on a provisioned VPS (the
+        bootstrap installs it as a systemd/launchd/scheduled-task service), so the
+        2-hourly ``PATCH /ml-api/contabo/allocation`` ping rides along here rather
+        than in ``agentd`` (optional) or the AI backend (would need inbound reach).
+        Opt out with ``AGENTOS_VPS_HEALTH=0``. See ``sdk.vps_health``.
+        """
+        from sdk import vps_health
+
+        task = None
+        try:
+            task = vps_health.start()
+        except Exception:  # noqa: BLE001 — the panel must serve even if the cron won't start
+            task = None
+        try:
+            yield
+        finally:
+            if task is not None:
+                task.cancel()
+                # CancelledError is a BaseException — suppress it explicitly, or the
+                # cancellation we just requested surfaces as a failed shutdown.
+                try:
+                    await task
+                except (asyncio.CancelledError, Exception):  # noqa: BLE001
+                    pass
+
     # Swagger at /docs (ReDoc /redoc, schema /openapi.json). By default the whole
     # server — docs included — is locked by the IP allowlist below. With
     # AGENTOS_UI_PUBLIC=1 the IP gate is lifted: /docs is browsable by anyone and
     # /api/ui/* is guarded solely by the co_ token (paste it in Swagger's Authorize).
     from sdk import __version__ as _sdk_version
-    app = FastAPI(title="AgentOS SDK", version=_sdk_version, docs_url="/docs", redoc_url="/redoc")
+    app = FastAPI(title="AgentOS SDK", version=_sdk_version, docs_url="/docs",
+                  redoc_url="/redoc", lifespan=lifespan)
     # Inbound half of the two-way link: unless AGENTOS_UI_PUBLIC=1, only loopback,
     # this host's own IPs, and whitelisted IPs (the AI backend) may reach the server
     # AT ALL. Configure via AGENTOS_UI_ALLOWED_IPS or the config.toml `allowed_ips` key.