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

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

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

{devops_bot_sdk-1.4.150 → devops_bot_sdk-1.4.153}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.150 → devops_bot_sdk-1.4.153}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -86,6 +86,7 @@ sdk/ui/static/setup.html
 sdk/ui/static/styles.css
 sdk/ui/static/tickets.html
 tests/test_agent_chat_features.py
+tests/test_agent_prompt_async.py
 tests/test_agent_prompt_models.py
 tests/test_agents_connectors_builder.py
 tests/test_git_action.py

{devops_bot_sdk-1.4.150 → devops_bot_sdk-1.4.153}/sdk/__init__.py

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

@@ -26,6 +26,7 @@ def _map_backend_agent(row: dict, source: str) -> dict:
     sys_prompt = prompt.get("system_prompt", "") if isinstance(prompt, dict) else ""
     pvars = prompt.get("variables", []) if isinstance(prompt, dict) else []
     return {
+        "id": row.get("id"),                 # backend agentId — used for activity webhook
         "name": row.get("name"),
         "description": sys_prompt[:200],
         "variables": [v.get("name") for v in pvars if isinstance(v, dict) and v.get("name")],

{devops_bot_sdk-1.4.150 → devops_bot_sdk-1.4.153}/sdk/client.py

@@ -37,6 +37,11 @@ from sdk.sse import _check_status, stream_with_reconnect
 
 logger = logging.getLogger(__name__)
 
+# Process-lifetime cache of agent NAME → backend agentId (""=known non-backend).
+# Used by resolve_agent_id so the agent-activity webhook fires only for backend
+# agents without a lookup on every run.
+_AGENT_ID_CACHE: dict[str, str] = {}
+
 # ── Ticket status-change observers ────────────────────────────────────────
 # Best-effort, synchronous hooks fired when the client changes a ticket's backend
 # status (In Progress / Backlog / To Do). The CLI loop registers one to track
@@ -1036,6 +1041,58 @@ class BackendClient:
             logger.warning("client.log_activity error err=%s", exc)
             return False
 
+    async def log_agent_activity(self, activity: str, agent_id: str) -> bool:
+        """POST {ML_GATEWAY_URL}/ml-api/agent-activity — record an agent-activity
+        event for a **backend** agent (body ``{activity, agentId}``). Best-effort;
+        never raises. No-op when ``agent_id`` is empty (local-only agents are not
+        tracked — the backend is the source of truth for agents).
+        """
+        from sdk.config import ML_GATEWAY_URL
+
+        aid = (agent_id or "").strip()
+        if not aid:
+            return False
+        url = f"{ML_GATEWAY_URL.rstrip('/')}/ml-api/agent-activity"
+        headers = {**self._headers, "accept": "*/*", "developer-name": "null", "product": ""}
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                resp = await client.post(
+                    url, json={"activity": str(activity), "agentId": aid}, headers=headers,
+                )
+            if resp.status_code >= 400:
+                logger.warning("client.log_agent_activity failed status=%s body=%s",
+                               resp.status_code, resp.text[:200])
+                return False
+            return True
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.log_agent_activity error err=%s", exc)
+            return False
+
+    async def resolve_agent_id(self, name: str) -> str | None:
+        """Best-effort backend ``agentId`` for an agent NAME (custom + department).
+
+        Returns None when the name isn't a backend agent (e.g. a local-only manifest)
+        — the caller then skips activity emit, so only backend agents are tracked.
+        Cached per process (the id↔name mapping is stable within a session).
+        """
+        nm = (name or "").strip()
+        if not nm:
+            return None
+        if nm in _AGENT_ID_CACHE:
+            return _AGENT_ID_CACHE[nm] or None
+        rows: list[dict] = []
+        for fetch in (self.list_custom_agents, self.list_department_agents):
+            try:
+                rows += await fetch()
+            except Exception:  # noqa: BLE001 — best-effort across both sources
+                pass
+        for r in rows:
+            if r.get("name") == nm and r.get("id"):
+                _AGENT_ID_CACHE[nm] = str(r["id"])
+                return _AGENT_ID_CACHE[nm]
+        _AGENT_ID_CACHE[nm] = ""     # negative-cache: not a backend agent
+        return None
+
     async def notify_whatsapp(
         self,
         task_id: str,

{devops_bot_sdk-1.4.150 → devops_bot_sdk-1.4.153}/sdk/config.py

@@ -25,7 +25,10 @@ _CONFIG_FILE = _CONFIG_DIR / "config.toml"
 _SENTINEL    = "co_"
 
 AI_DEFAULT_URL = "https://devopsbot-ai.apiswagger.co.uk"
-BE_DEFAULT_URL = "https://devopsbot-be.apiswagger.co.uk"
+# ML backend / gateway — all /ml-api, /tasks-ml, /approvals-ml, agent-activity, etc.
+# now go through the ML gateway (was devopsbot-be.apiswagger.co.uk).
+BE_DEFAULT_URL = "https://gateway-ml.apiswagger.co.uk"
+ML_GATEWAY_URL = "https://gateway-ml.apiswagger.co.uk"
 
 
 # ── Machine-derived Fernet key ────────────────────────────────────────
@@ -146,6 +149,13 @@ def _dotenv_value(key: str) -> str:
     return ""
 
 
+# Built-in permanent allowlist — the central AI backend's IP(s). Baked in so the
+# backend can reach EVERY VPS's /api/ui/* out of the box (no per-VPS .env needed);
+# always allowed, treated as permanent (not removable via the API). Extend/override
+# with AGENTOS_UI_ALLOWED_IPS in .env or the process env.
+_DEFAULT_ALLOWED_IPS: list[str] = ["20.12.201.148"]
+
+
 def _parse_ip_list(raw: str) -> list[str]:
     """Split an IP allowlist string, tolerant of JSON-ish list syntax.
 
@@ -178,6 +188,7 @@ def get_allowed_ips() -> list[str]:
     change. CIDR/prefix entries are supported by the middleware.
     """
     sources = [
+        ",".join(_DEFAULT_ALLOWED_IPS),                 # built-in backend IP(s) — always allowed
         _dotenv_value("AGENTOS_UI_ALLOWED_IPS"),
         os.environ.get("AGENTOS_UI_ALLOWED_IPS", ""),
         _load_raw().get("allowed_ips", ""),
@@ -202,7 +213,8 @@ def permanent_allowed_ips() -> list[str]:
     through the API — change them by editing ``.env`` and restarting.
     """
     out: list[str] = []
-    for src in (_dotenv_value("AGENTOS_UI_ALLOWED_IPS"),
+    for src in (",".join(_DEFAULT_ALLOWED_IPS),          # built-in backend IP(s) — always permanent
+                _dotenv_value("AGENTOS_UI_ALLOWED_IPS"),
                 os.environ.get("AGENTOS_UI_ALLOWED_IPS", "")):
         for ip in _parse_ip_list(src):
             if ip not in out:

{devops_bot_sdk-1.4.150 → devops_bot_sdk-1.4.153}/sdk/ui/api.py

@@ -304,6 +304,28 @@ 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.
+
+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
+
+
 # ── Agents: catalog, creation, chat, default agents ────────────────────────
 
 @router.get("/connectors", dependencies=[_auth])
@@ -689,12 +711,14 @@ async def agent_chat(body: AgentChatRequest) -> dict:
         started = _time.monotonic()
         result = await _run()
 
+        elapsed = _time.monotonic() - started
         usage_mod.record(
-            name, kind="chat", duration_s=_time.monotonic() - started,
+            name, kind="chat", duration_s=elapsed,
             input_tokens=result.get("input_tokens", 0),
             output_tokens=result.get("output_tokens", 0),
             cost_usd=result.get("cost_usd", 0.0), ok=bool(result.get("ok")),
         )
+        await _emit_agent_activity(name, "chat", result, elapsed)
         return result
 
     # Run detached from this request: navigating away can't kill it. Poll
@@ -732,12 +756,14 @@ async def agent_run(body: AgentRunRequest) -> dict:
         started = _time.monotonic()
         result = await _run()
 
+        elapsed = _time.monotonic() - started
         usage_mod.record(
-            name, kind="run", duration_s=_time.monotonic() - started,
+            name, kind="run", duration_s=elapsed,
             input_tokens=result.get("input_tokens", 0),
             output_tokens=result.get("output_tokens", 0),
             cost_usd=result.get("cost_usd", 0.0), ok=bool(result.get("ok")),
         )
+        await _emit_agent_activity(name, "run", result, elapsed)
         return result
 
     return {"job_id": jobs.start(work())}
@@ -968,55 +994,70 @@ async def _screen_agent_inputs(agent_name: str, agent_type: str, job: str) -> li
 async def agent_prompt_generate(body: AgentPromptGenerateRequest) -> dict:
     """name + type + job → a structured system prompt + {{variables}} (claude_code).
 
-    Body: ``agent_name``, ``agent_type``, ``job``, optional ``context``.
-    Returns ``{agent_name, agent_type, system_prompt, variables[], engine}``.
+    ASYNC: local Claude Code generation can take a while, so this starts a detached
+    job and returns ``{job_id}`` immediately (navigation-safe, and no long request
+    held across a proxy/gateway — avoids 504s). Poll ``GET /api/ui/jobs/{job_id}``
+    for the result: ``{status, engine, ai_comments, agent_name, agent_type,
+    system_prompt, variables[]}`` (or ``status="needs_revision"`` / ``"error"``).
     """
     from sdk.agents.prompt_studio import build_generate_prompt, parse_generation
+    from sdk.ui import jobs
 
     # Empty agent_name/agent_type/job already 422'd by the request model.
     agent_name = body.agent_name
     agent_type = body.agent_type
     job = body.job
+    context = body.context
+
+    async def work():
+        # Semantic screen (offensive / meaningless) → unified needs_revision. Fail-open.
+        comments = await _screen_agent_inputs(agent_name, agent_type, job)
+        if comments:
+            return _needs_revision(comments)
+        text = await _run_prompt_engine(build_generate_prompt(agent_name, agent_type, job, context))
+        parsed = parse_generation(text)
+        if not parsed["system_prompt"]:
+            return {"status": "error", "engine": "claude_code", "ai_comments": [],
+                    "error": "generation returned no system_prompt"}
+        return {"status": "ok", "engine": "claude_code", "ai_comments": [],
+                "agent_name": agent_name, "agent_type": agent_type, **parsed}
 
-    # Semantic screen (offensive / meaningless) → unified needs_revision. Fail-open.
-    comments = await _screen_agent_inputs(agent_name, agent_type, job)
-    if comments:
-        return _needs_revision(comments)
-
-    text = await _run_prompt_engine(
-        build_generate_prompt(agent_name, agent_type, job, body.context)
-    )
-    parsed = parse_generation(text)
-    if not parsed["system_prompt"]:
-        raise HTTPException(status_code=502, detail="generation returned no system_prompt")
-    return {"status": "ok", "engine": "claude_code", "ai_comments": [],
-            "agent_name": agent_name, "agent_type": agent_type, **parsed}
+    return {"job_id": jobs.start(work())}
 
 
 @router.post("/agent-prompt/regenerate", dependencies=[_auth])
 async def agent_prompt_regenerate(body: PromptRegenerateRequest) -> dict:
     """Improve an existing prompt (optional feedback) → prompt + {{variables}}.
 
-    Body: ``system_prompt``, optional ``feedback``, ``agent_name``, ``agent_type``,
-    ``job``. Same response shape as /agent-prompt/generate.
+    ASYNC (same as generate): returns ``{job_id}``; poll ``GET /api/ui/jobs/{job_id}``.
+    Body: ``system_prompt``, optional ``feedback``, ``agent_name``, ``agent_type``, ``job``.
     """
     from sdk.agents.prompt_studio import build_regenerate_prompt, parse_generation
+    from sdk.ui import jobs
 
-    # Empty system_prompt already 422'd by the request model. Screen the agent
-    # metadata (blank fields ignored by the screener; fail-open).
-    comments = await _screen_agent_inputs(body.agent_name, body.agent_type, body.job)
-    if comments:
-        return _needs_revision(comments)
+    # Empty system_prompt already 422'd by the request model.
+    agent_name = body.agent_name
+    agent_type = body.agent_type
+    job = body.job
+    system_prompt = body.system_prompt
+    feedback = body.feedback
+
+    async def work():
+        # Screen the agent metadata (blank fields ignored by the screener; fail-open).
+        comments = await _screen_agent_inputs(agent_name, agent_type, job)
+        if comments:
+            return _needs_revision(comments)
+        text = await _run_prompt_engine(build_regenerate_prompt(
+            system_prompt, feedback, agent_name, agent_type, job,
+        ))
+        parsed = parse_generation(text)
+        if not parsed["system_prompt"]:
+            return {"status": "error", "engine": "claude_code", "ai_comments": [],
+                    "error": "regeneration returned no system_prompt"}
+        return {"status": "ok", "engine": "claude_code", "ai_comments": [],
+                "agent_name": agent_name, "agent_type": agent_type, **parsed}
 
-    text = await _run_prompt_engine(build_regenerate_prompt(
-        body.system_prompt, body.feedback,
-        body.agent_name, body.agent_type, body.job,
-    ))
-    parsed = parse_generation(text)
-    if not parsed["system_prompt"]:
-        raise HTTPException(status_code=502, detail="regeneration returned no system_prompt")
-    return {"status": "ok", "engine": "claude_code", "ai_comments": [],
-            "agent_name": body.agent_name, "agent_type": body.agent_type, **parsed}
+    return {"job_id": jobs.start(work())}
 
 
 @router.post("/agent-prompt/verify", dependencies=[_auth])
@@ -1025,53 +1066,57 @@ async def agent_prompt_verify(body: PromptVerifyRequest) -> dict:
 
     Standards check is deterministic (our Role/Objective/Rules/Workflow/Output
     template); secrets + variable metadata are inferred by Claude Code locally.
-    Body: ``system_prompt`` → ``{valid, missing_required, missing_recommended,
-    variables[], secrets[]}``.
+    ASYNC: returns ``{job_id}``; poll ``GET /api/ui/jobs/{job_id}`` → ``{valid,
+    missing_required, missing_recommended, variables[], secrets[], ...}``.
     """
     from sdk.agents.prompt_studio import build_analyze_prompt, parse_analysis
     from sdk.agents.prompt_template import check_system_prompt
     from sdk.agents.prompt_vars import extract_variables
+    from sdk.ui import jobs
 
     # Too-short system_prompt already 422'd by the request model.
     system_prompt = body.system_prompt
 
-    standards = check_system_prompt(system_prompt)
+    async def work():
+        standards = check_system_prompt(system_prompt)
 
-    # Enrichment (secrets + variable metadata) via local Claude Code — best-effort:
-    # a failure must not sink the deterministic verdict.
-    analysis: dict = {"inputs": [], "secrets": []}
-    try:
-        analysis = parse_analysis(await _run_prompt_engine(build_analyze_prompt(system_prompt)))
-    except HTTPException:
-        pass
+        # Enrichment (secrets + variable metadata) via local Claude Code — best-effort:
+        # a failure must not sink the deterministic verdict.
+        analysis: dict = {"inputs": [], "secrets": []}
+        try:
+            analysis = parse_analysis(await _run_prompt_engine(build_analyze_prompt(system_prompt)))
+        except HTTPException:
+            pass
+
+        meta = {str(i.get("name", "")).strip(): i for i in analysis.get("inputs", []) if isinstance(i, dict)}
+        variables = []
+        for name in extract_variables(system_prompt):          # {{placeholders}} are authoritative
+            m = meta.get(name, {})
+            variables.append({
+                "name": name,
+                "label": str(m.get("label") or name.replace("_", " ").title()).strip(),
+                "description": str(m.get("description", "")).strip(),
+                "type": str(m.get("type", "string")).strip() or "string",
+            })
+
+        # Structural gaps → the SAME unified ai_comments list (all messages together).
+        ai_comments = (
+            [f"Missing required section: {s}." for s in standards["missing_required"]]
+            + [f"Recommended section missing: {s}." for s in standards["missing_recommended"]]
+        )
 
-    meta = {str(i.get("name", "")).strip(): i for i in analysis.get("inputs", []) if isinstance(i, dict)}
-    variables = []
-    for name in extract_variables(system_prompt):          # {{placeholders}} are authoritative
-        m = meta.get(name, {})
-        variables.append({
-            "name": name,
-            "label": str(m.get("label") or name.replace("_", " ").title()).strip(),
-            "description": str(m.get("description", "")).strip(),
-            "type": str(m.get("type", "string")).strip() or "string",
-        })
-
-    # Structural gaps → the SAME unified ai_comments list (all messages together).
-    ai_comments = (
-        [f"Missing required section: {s}." for s in standards["missing_required"]]
-        + [f"Recommended section missing: {s}." for s in standards["missing_recommended"]]
-    )
+        return {
+            "status": "needs_revision" if standards["missing_required"] else "ok",
+            "engine": "claude_code",
+            "ai_comments": ai_comments,
+            "valid": not standards["missing_required"],
+            "missing_required": standards["missing_required"],
+            "missing_recommended": standards["missing_recommended"],
+            "variables": variables,
+            "secrets": analysis.get("secrets", []),
+        }
 
-    return {
-        "status": "needs_revision" if standards["missing_required"] else "ok",
-        "engine": "claude_code",
-        "ai_comments": ai_comments,
-        "valid": not standards["missing_required"],
-        "missing_required": standards["missing_required"],
-        "missing_recommended": standards["missing_recommended"],
-        "variables": variables,
-        "secrets": analysis.get("secrets", []),
-    }
+    return {"job_id": jobs.start(work())}
 
 
 @router.get("/agents/form", dependencies=[_auth])

{devops_bot_sdk-1.4.150 → devops_bot_sdk-1.4.153}/sdk/updater.py

@@ -132,10 +132,10 @@ def _ml_api_base() -> str:
     try:
         from sdk.config import get_base_url
         base = get_base_url()
-        # devopsbot-ai.apiswagger.co.uk  →  devopsbot-be.apiswagger.co.uk
-        return base.replace("devopsbot-ai", "devopsbot-be")
+        # devopsbot-ai.apiswagger.co.uk  →  gateway-ml.apiswagger.co.uk
+        return base.replace("devopsbot-ai.apiswagger.co.uk", "gateway-ml.apiswagger.co.uk")
     except Exception:  # noqa: BLE001
-        return "https://devopsbot-be.apiswagger.co.uk"
+        return "https://gateway-ml.apiswagger.co.uk"
 
 
 def _env_github_token() -> str | None:

devops_bot_sdk-1.4.153/tests/test_agent_prompt_async.py

@@ -0,0 +1,74 @@
+"""Agent-prompt endpoints are async job-based (avoids long requests / 504s).
+
+POST /api/ui/agent-prompt/{generate,regenerate,verify} return `{job_id}`
+immediately — the local Claude Code run happens in the background; the result is
+fetched from GET /api/ui/jobs/{job_id}.
+
+Note: we assert the async *contract* (an immediate `{job_id}`). Driving the
+background job to completion isn't done via the sync TestClient (each request
+runs its own event loop, so a detached task from the POST doesn't advance across
+later GETs) — that's a harness limitation, not a code one. The job's *result*
+logic is unchanged from the pre-async version (just wrapped in `work()`).
+"""
+from __future__ import annotations
+
+import re
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+fastapi = pytest.importorskip("fastapi")
+from fastapi.testclient import TestClient  # noqa: E402
+
+from sdk.ui.api import require_token, router  # noqa: E402
+
+_JOB_RE = re.compile(r"^[0-9a-f]{32}$")   # uuid4().hex
+
+
+def _client():
+    app = fastapi.FastAPI()
+    app.include_router(router)
+    app.dependency_overrides[require_token] = lambda: None
+    return TestClient(app)
+
+
+# Keep the local Claude Code call mocked so a background task (if it runs) never
+# shells out to a real `claude`. Autouse across this module.
+@pytest.fixture(autouse=True)
+def _no_real_claude():
+    with patch("sdk.ui.api._run_prompt_engine", AsyncMock(return_value="<raw>")), \
+         patch("sdk.ui.api._screen_agent_inputs", AsyncMock(return_value=[])):
+        yield
+
+
+class TestAsyncContract:
+    def test_generate_returns_job_id(self):
+        resp = _client().post("/api/ui/agent-prompt/generate", json={
+            "agent_name": "Repo Onboarder", "agent_type": "developer",
+            "job": "summarise a repo", "context": "", "engine": "claude_code"})
+        assert resp.status_code == 200
+        body = resp.json()
+        assert set(body) == {"job_id"} and _JOB_RE.match(body["job_id"])
+
+    def test_regenerate_returns_job_id(self):
+        resp = _client().post("/api/ui/agent-prompt/regenerate", json={
+            "system_prompt": "# Role\n## Objective\nDo X with {{repo_url}}.",
+            "feedback": "stricter", "engine": "claude_code"})
+        assert resp.status_code == 200
+        assert _JOB_RE.match(resp.json()["job_id"])
+
+    def test_verify_returns_job_id(self):
+        resp = _client().post("/api/ui/agent-prompt/verify", json={
+            "system_prompt": "# Role\n## Objective\n## Rules\n## Output\nUse {{repo_url}}."})
+        assert resp.status_code == 200
+        assert _JOB_RE.match(resp.json()["job_id"])
+
+    def test_verify_still_422_on_short_prompt(self):
+        # Validation stays synchronous (before the job) — no job id for bad input.
+        resp = _client().post("/api/ui/agent-prompt/verify", json={"system_prompt": "short"})
+        assert resp.status_code == 422
+
+    def test_generate_still_422_on_empty_required(self):
+        resp = _client().post("/api/ui/agent-prompt/generate",
+                              json={"agent_name": "", "agent_type": "x", "job": "y"})
+        assert resp.status_code == 422