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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.153
+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.153 → 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.153
+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.153 → 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
@@ -35,6 +37,7 @@ sdk/agents/prompt_template.py
 sdk/agents/prompt_vars.py
 sdk/agents/run_log.py
 sdk/agents/secrets.py
+sdk/agents/ticket_run.py
 sdk/agents/usage.py
 sdk/agents/varstore.py
 sdk/agents/engines/__init__.py
@@ -75,20 +78,26 @@ sdk/ui/runner.py
 sdk/ui/security.py
 sdk/ui/server.py
 sdk/ui/service.py
+sdk/ui/session.py
 sdk/ui/setup_manager.py
 sdk/ui/static/agents.html
 sdk/ui/static/app.js
 sdk/ui/static/custom-agents.html
 sdk/ui/static/default-agents.html
 sdk/ui/static/index.html
+sdk/ui/static/login.html
 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_health.py
-tests/test_updater_extras.py
+tests/test_otp_login.py
+tests/test_updater_extras.py
+tests/test_vps_health.py

{devops_bot_sdk-1.4.153 → 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.153 → 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.153 → devops_bot_sdk-1.4.159}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.4.153
+Version: 1.4.154
 
 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.153"   # 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.153 → 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
 
@@ -251,7 +252,9 @@ async def _wait_for_human_approval(client: BackendClient, task_id: str) -> str:
 
 async def _dispatch_agent_run(
     manifest: "AgentManifest", client: BackendClient, task: dict | None = None,
-) -> None:
+    *, auto_approve: bool = False,
+    extra_variables: dict | None = None, extra_secrets: dict | None = None,
+) -> dict:
     """Run ONE loaded ``AgentManifest`` end to end, for one trigger firing.
 
     1. Resolve skills + (optionally) an MCP config from the manifest.
@@ -262,7 +265,8 @@ async def _dispatch_agent_run(
        run, but pauses at ``awaiting_approval`` instead of executing, exactly
        like the desktop's local-execution hybrid for Jira coding tasks.
     4. Drive the GO-AHEAD / FINALIZE round-trip:
-         - ``approval.policy == "never"``: agentd sends the GO-AHEAD itself
+         - ``auto_approve`` (a human-initiated on-demand run) OR
+           ``approval.policy == "never"``: agentd sends the GO-AHEAD itself
            (``approval_reply(..., decision="APPROVED", local_execution_result=None)``)
            the moment the run reaches ``awaiting_approval``.
          - otherwise: wait for a human's WhatsApp reply to land (no early
@@ -271,7 +275,15 @@ async def _dispatch_agent_run(
        ``sdk.agents.engines.claude_code.run`` and report the result back via
        a second ``approval_reply(..., local_execution_result={...})`` call,
        which finalizes the run server-side.
+
+    ``auto_approve=True`` is used by the on-demand "run agent on a ticket" path
+    (UI / API / CLI), where a human already clicked Run — so the agent's
+    ``approval.policy`` WhatsApp gate is skipped for this single run.
+
+    Returns an outcome dict — ``{status, task_id, result, ok, error}`` — for the
+    on-demand callers; the daemon's trigger loops ignore the return value.
     """
+    outcome: dict = {"status": "", "task_id": "", "result": "", "ok": False, "error": ""}
     from sdk.agents import integrations as integrations_mod
     from sdk.agents import manifest as manifest_mod
     from sdk.agents import secrets as agent_secrets
@@ -284,7 +296,15 @@ async def _dispatch_agent_run(
     # only when the owner edits the agent. Empty for department agents, whose keys
     # come from the host .env already in os.environ.
     stored_secrets = agent_secrets.load_secrets(manifest.name)
-    secret_env = agent_secrets.resolved_env(manifest.name) if stored_secrets else None
+    # EPHEMERAL secrets: supplied for THIS run only (UI/API/CLI), merged on top of
+    # any stored keys and injected as env — NEVER written back to disk, so they
+    # vanish when the run ends. Explicit run-time values win over stored ones.
+    effective_secrets = {**(stored_secrets or {}), **(extra_secrets or {})}
+    if extra_secrets:
+        import os as _os
+        secret_env = {**_os.environ, **effective_secrets}
+    else:
+        secret_env = agent_secrets.resolved_env(manifest.name) if stored_secrets else None
 
     mcp_config: dict[str, Any] | None = None
     if manifest.integrations:
@@ -293,21 +313,23 @@ async def _dispatch_agent_run(
             manifest.integrations, available, env=secret_env,
         )
 
-    # EPHEMERAL variables: refilled FRESH from THIS ticket every run (never
-    # persisted). A scheduled/manual run with no ticket leaves them for the agent
-    # to ask about or default, exactly as before.
+    # EPHEMERAL variables: filled FRESH from the ticket (when one is attached) and/or
+    # from explicit run-time values — never persisted. Explicit ``extra_variables``
+    # win over ticket-derived ones. With neither, unresolved {{vars}} are left for
+    # the agent to ask about or default, exactly as before.
     resolved_prompt = manifest.prompt
-    if task:
-        names = extract_variables(manifest.prompt)
-        if names:
-            values = values_from_ticket(names, task)
-            resolved_prompt, missing = substitute_variables(manifest.prompt, values)
-            if values:
-                logger.info(
-                    "agentd.vars_filled agent=%s filled=%s missing=%s",
-                    manifest.name, sorted(values), sorted(missing),
-                )
-            manifest = manifest.model_copy(update={"prompt": resolved_prompt})
+    names = extract_variables(manifest.prompt)
+    if names and (task or extra_variables):
+        values = values_from_ticket(names, task) if task else {}
+        if extra_variables:
+            values = {**values, **{k: str(v) for k, v in extra_variables.items() if str(v).strip()}}
+        resolved_prompt, missing = substitute_variables(manifest.prompt, values)
+        if values:
+            logger.info(
+                "agentd.vars_filled agent=%s filled=%s missing=%s",
+                manifest.name, sorted(values), sorted(missing),
+            )
+        manifest = manifest.model_copy(update={"prompt": resolved_prompt})
 
     if manifest.engine != "claude_code":
         # Only claude_code is wired end-to-end today (sdk/agents/engines/{mcp,
@@ -317,7 +339,8 @@ async def _dispatch_agent_run(
         logger.warning(
             "agentd.engine_not_wired engine=%s agent=%s", manifest.engine, manifest.name,
         )
-        return
+        outcome["error"] = f"engine '{manifest.engine}' is not wired (only claude_code)."
+        return outcome
 
     prompt_text = manifest.prompt
     if skill_text:
@@ -332,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":
@@ -341,8 +367,9 @@ async def _dispatch_agent_run(
             return
         handled.add(task_id)
 
-        if policy == "never":
-            # No human in the loop for this agent — agentd IS the approver.
+        if auto_approve or policy == "never":
+            # No human in the loop for this run — agentd IS the approver
+            # (agent policy 'never', or a human already clicked Run on-demand).
             try:
                 await client.approval_reply(
                     task_id, decision="APPROVED", local_execution_result=None,
@@ -379,16 +406,36 @@ 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=stored_secrets or None,
+                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", ""),
+                "ok": bool(local_result.get("ok", True)),
+            })
         except Exception as exc:  # noqa: BLE001
             logger.warning(
                 "agentd.local_run_failed agent=%s task=%s err=%s",
                 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
@@ -417,11 +464,14 @@ async def _dispatch_agent_run(
         result = await client.orchestrate(req, on_status_update=_on_status_update)
     except Exception as exc:  # noqa: BLE001
         logger.warning("agentd.orchestrate_failed agent=%s err=%s", manifest.name, exc)
-        return
+        outcome["error"] = str(exc)
+        return outcome
 
     logger.info(
         "agentd.run_complete agent=%s status=%s", manifest.name, getattr(result, "status", ""),
     )
+    outcome["status"] = getattr(result, "status", "") or ""
+    return outcome
 
 
 # ── The daemon ───────────────────────────────────────────────────────────────

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.159/sdk/agents/ticket_run.py

@@ -0,0 +1,97 @@
+"""On-demand "run an agent ON a Jira ticket" — the manual counterpart to the
+``agentd`` ``ticket_label`` trigger.
+
+The daemon fires an agent when a To-Do ticket carries its label; this module
+lets a human pick an agent AND a ticket and run it now (from the UI, the API, or
+the CLI). It reuses the exact same engine — ``agentd._dispatch_agent_run`` — so
+the ticket's fields fill the agent's ``{{variables}}`` and the work is planned,
+gated, executed locally, and reported back to the platform against that ticket.
+
+Because a human initiated the run, ``auto_approve=True`` is passed: the GO-AHEAD
+is sent immediately, skipping the agent's ``approval.policy`` WhatsApp gate for
+this single run.
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from sdk.agents.manifest import AgentManifest
+    from sdk.client import BackendClient
+
+
+async def resolve_manifest(
+    client: "BackendClient", name: str, scope: str = "custom", department_id: str = "",
+) -> "AgentManifest | None":
+    """Find the agent manifest to run, by ``scope``.
+
+    * ``custom`` (default) — a personal agent from the local manifests
+      (``~/.agentos/agents``).
+    * ``department`` — an ACTIVE department default pulled from the backend
+      (``list_department_agents``), materialized read-only (never written back),
+      exactly as ``agentd._load_department_agents`` does.
+
+    Returns None when no matching agent is found.
+    """
+    from sdk.agents.manifest import AgentManifest, load_agents
+
+    name = (name or "").strip()
+    if scope == "department":
+        try:
+            rows = await client.list_department_agents()
+        except Exception:  # noqa: BLE001 — treat a backend hiccup as "not found"
+            return None
+        for row in rows:
+            if row.get("name") == name and row.get("status") == "active":
+                try:
+                    return AgentManifest(**row["manifest"])
+                except Exception:  # noqa: BLE001 — invalid manifest → not runnable
+                    return None
+        return None
+
+    for m in load_agents():
+        if m.name == name:
+            return m
+    return None
+
+
+async def run_on_ticket(
+    client: "BackendClient", name: str, ticket_key: str = "",
+    scope: str = "custom", department_id: str = "",
+    variables: dict | None = None, secrets: dict | None = None,
+) -> dict:
+    """Run agent ``name`` (``scope``) now, OPTIONALLY against a Jira ticket.
+
+    * ``ticket_key`` — optional. When given, the ticket record is fetched (any
+      board status — a targeted run may re-run a Done ticket) and its fields fill
+      the agent's ``{{variables}}``. When omitted, the agent runs without a ticket.
+    * ``variables`` — optional EPHEMERAL ``{{var}}`` values for this run; they win
+      over ticket-derived values and are never persisted.
+    * ``secrets`` — optional EPHEMERAL env secrets for this run only; injected for
+      the engine invocation and never written to the agent's stored keys.
+
+    Resolves the manifest and dispatches through the shared pipeline with
+    ``auto_approve=True``. Returns the dispatch outcome dict
+    (``{status, task_id, result, ok, error}``).
+
+    Raises ``ValueError`` when the agent — or an explicitly-named ticket — cannot
+    be found, so the caller reports a clear message.
+    """
+    from sdk.agentd import _dispatch_agent_run
+
+    key = (ticket_key or "").strip()
+    task: dict | None = None
+    if key:
+        records = await client.list_tasks_by_keys([key])
+        if not records:
+            raise ValueError(f"Jira ticket '{key}' was not found.")
+        task = records[0]
+
+    manifest = await resolve_manifest(client, name, scope=scope, department_id=department_id)
+    if manifest is None:
+        raise ValueError(f"Agent '{name}' was not found (scope={scope}).")
+
+    return await _dispatch_agent_run(
+        manifest, client, task, auto_approve=True,
+        extra_variables=variables or None, extra_secrets=secrets or None,
+    )

{devops_bot_sdk-1.4.153 → devops_bot_sdk-1.4.159}/sdk/cli.py

@@ -131,6 +131,9 @@ def _agent_command(args: list[str]) -> None:
     if verb == "run" and rest:
         _agent_run(rest[0])
         return
+    if verb == "run-ticket" and rest:
+        _agent_run_ticket(rest[0], rest[1:])
+        return
     if verb == "chat" and len(rest) >= 2:
         _agent_chat(rest[0], " ".join(rest[1:]))
         return
@@ -156,17 +159,29 @@ def _agent_command(args: list[str]) -> None:
         _agent_rm_key(rest[0], rest[1:])
         return
 
-    print("usage: agentos agent <new|add PATH|list|run NAME|chat NAME MESSAGE|template [NAME]|"
-          "logs NAME|enable NAME|disable NAME|rm NAME|set-key NAME KEY[=VALUE]…|keys NAME|"
-          "rm-key NAME KEY…>")
+    print("usage: agentos agent <new|add PATH|list|run NAME|run-ticket NAME [--ticket KEY] "
+          "[--var k=v]… [--secret K=V]… [--scope department --department-id UUID]|chat NAME MESSAGE|"
+          "template [NAME]|logs NAME|enable NAME|disable NAME|rm NAME|set-key NAME KEY[=VALUE]…|"
+          "keys NAME|rm-key NAME KEY…>")
     sys.exit(1)
 
 
 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)
@@ -220,6 +235,61 @@ def _agent_list() -> None:
         )
 
 
+def _agent_run_ticket(name: str, flags: list[str]) -> None:
+    """`agentos agent run-ticket NAME [--ticket KEY] [--var k=v]… [--secret K=V]…
+    [--scope department] [--department-id UUID]`.
+
+    Runs the agent through the platform pipeline. A ``--ticket`` is OPTIONAL (its
+    fields fill the agent's ``{{variables}}``); ``--var``/``--secret`` are
+    EPHEMERAL (this run only, never stored). Auto-approved.
+    """
+    from sdk.agents import ticket_run
+    from sdk.client import BackendClient
+
+    scope, department_id, ticket_key = "custom", "", ""
+    variables: dict = {}
+    secrets: dict = {}
+    i = 0
+    while i < len(flags):
+        f = flags[i]
+        if f == "--ticket" and i + 1 < len(flags):
+            ticket_key = flags[i + 1]; i += 2
+        elif f == "--scope" and i + 1 < len(flags):
+            scope = flags[i + 1]; i += 2
+        elif f == "--department-id" and i + 1 < len(flags):
+            department_id = flags[i + 1]; i += 2
+        elif f == "--var" and i + 1 < len(flags):
+            k, _, v = flags[i + 1].partition("=")
+            if k.strip():
+                variables[k.strip()] = v
+            i += 2
+        elif f == "--secret" and i + 1 < len(flags):
+            k, _, v = flags[i + 1].partition("=")
+            if k.strip():
+                secrets[k.strip()] = v
+            i += 2
+        else:
+            i += 1
+
+    client = BackendClient.from_config()
+    try:
+        outcome = asyncio.run(ticket_run.run_on_ticket(
+            client, name, ticket_key, scope=scope, department_id=department_id,
+            variables=variables or None, secrets=secrets or None,
+        ))
+    except ValueError as exc:
+        print(f"error: {exc}")
+        sys.exit(1)
+
+    if outcome.get("error"):
+        print(f"error: {outcome['error']}")
+        sys.exit(1)
+    target = f" on {ticket_key}" if ticket_key else ""
+    print(f"ran '{name}'{target} — status={outcome.get('status') or 'done'}")
+    if outcome.get("result"):
+        print(f"\n{outcome['result']}")
+
+
 def _agent_run(name: str) -> None:
     from sdk.agents.manifest import AgentManifest, load_agents
     from sdk.client import BackendClient

{devops_bot_sdk-1.4.153 → 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,