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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.151
+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.151 → 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.151
+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.151 → 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.151 → 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.151
+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.151"   # 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.151 → devops_bot_sdk-1.4.153}/sdk/config.py

@@ -149,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.
 
@@ -181,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", ""),
@@ -205,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.151 → devops_bot_sdk-1.4.153}/sdk/ui/api.py

@@ -994,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])
@@ -1051,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.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