devops-bot-sdk 1.4.117__tar.gz → 1.4.118__tar.gz

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.118}/PKG-INFO

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

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.118}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.118}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -67,6 +67,7 @@ sdk/models/snapshots.py
 sdk/ui/__init__.py
 sdk/ui/api.py
 sdk/ui/dashboard.py
+sdk/ui/ip_allowlist.py
 sdk/ui/jobs.py
 sdk/ui/runner.py
 sdk/ui/security.py

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.118}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devops-bot-sdk"
-version = "1.4.117"
+dynamic = ["version"]                 # single source of truth: sdk/__init__.py __version__
 description = "DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app"
 readme = "README.md"
 license = "LicenseRef-Proprietary"
@@ -49,6 +49,9 @@ agentos-ui = "sdk.ui.server:main"           # local web control panel (needs the
 Homepage   = "https://agentos.io"
 Repository = "https://github.com/consultancy-outfit/DevOpsBot-SDK"
 
+[tool.setuptools.dynamic]
+version = { attr = "sdk.__version__" }   # bump sdk/__init__.py → wheel + client + server all follow
+
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["sdk*"]

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.118}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.4.117
+Version: 1.4.118
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -30,8 +30,8 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.4.117"
-__author__  = "AgentOS"
+__version__ = "1.4.118"   # 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
 from sdk.exceptions import (

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.118}/sdk/agents/prompt_studio.py

@@ -92,6 +92,110 @@ def build_comments_prompt(system_prompt: str) -> str:
     return COMMENTS_INSTRUCTION.replace("__SYSTEM_PROMPT__", system_prompt.strip())
 
 
+# ── Generate: name + type + job → a full system prompt with {{variables}} ────
+# This is the claude_code engine's authoring instruction. It runs LOCALLY in the
+# SDK (run_claude_local); the AI backend calls this SDK endpoint on the VPS.
+
+GENERATE_INSTRUCTION = (
+    "You are an expert prompt engineer. Write the SYSTEM PROMPT for a reusable AI "
+    "agent, given its NAME, TYPE, and main JOB. Produce a single, self-contained "
+    "prompt that follows EXACTLY this structure and Markdown headings:\n"
+    "# Role\nYou are <NAME>, <one-line identity from the type and job>.\n"
+    "## Objective\n<one paragraph: the single outcome this agent must produce>\n"
+    "## Rules\n- <hard constraints and guardrails>\n"
+    "- Never embed secrets; reference credentials as ${ENV_VAR} placeholders.\n"
+    "## Workflow\n1. <ordered steps to do the job>\n"
+    "## Output\n<exactly what the agent returns and in what format>\n\n"
+    "VARIABLE RULE (critical): any value the user must supply AT RUN TIME must "
+    "appear in the prompt text as {{variable_name}} (double curly braces, "
+    "snake_case). Only create a variable when the job genuinely needs a per-run "
+    "input; a self-contained agent may have NONE. Do not invent placeholders for "
+    "things the agent can work out itself.\n"
+    "Return ONLY a single minified JSON object, no prose, of the exact shape:\n"
+    '{"system_prompt":"<full prompt text with \\n line breaks and {{vars}} inline>",'
+    '"variables":[{"name":"","label":"","description":"","type":"string"}]}\n'
+    "Every {{variable}} in system_prompt MUST have a matching entry in variables, "
+    "and vice-versa. If there are none, return \"variables\": [].\n\n"
+    "AGENT NAME: __NAME__\nAGENT TYPE: __TYPE__\nMAIN JOB: __JOB____CONTEXT__"
+)
+
+REGENERATE_INSTRUCTION = (
+    "You are an expert prompt engineer. REGENERATE and improve the EXISTING system "
+    "prompt below. The same rules as a fresh prompt apply: keep the exact structure "
+    "(# Role / ## Objective / ## Rules / ## Workflow / ## Output), keep "
+    "{{variable_name}} placeholders for every per-run input, and keep every "
+    "{{variable}} and the variables list in sync. Preserve the original intent and "
+    "any working variables; fix structure, clarity, missing sections, weak rules, "
+    "and vague output specs. Apply the FEEDBACK if given.\n"
+    "Return ONLY a single minified JSON object of the exact shape:\n"
+    '{"system_prompt":"...","variables":[{"name":"","label":"","description":"","type":"string"}]}\n\n'
+    "__META__FEEDBACK: __FEEDBACK__\n\nEXISTING SYSTEM PROMPT:\n```\n__PROMPT__\n```"
+)
+
+
+def build_generate_prompt(agent_name: str, agent_type: str, job: str,
+                          context: str = "") -> str:
+    ctx = f"\nADDITIONAL CONTEXT: {context.strip()}" if context and context.strip() else ""
+    return (
+        GENERATE_INSTRUCTION
+        .replace("__NAME__", (agent_name or "").strip())
+        .replace("__TYPE__", (agent_type or "").strip())
+        .replace("__JOB__", (job or "").strip())
+        .replace("__CONTEXT__", ctx)
+    )
+
+
+def build_regenerate_prompt(system_prompt: str, feedback: str = "",
+                            agent_name: str = "", agent_type: str = "",
+                            job: str = "") -> str:
+    meta_bits = []
+    if (agent_name or "").strip():
+        meta_bits.append(f"AGENT NAME: {agent_name.strip()}")
+    if (agent_type or "").strip():
+        meta_bits.append(f"AGENT TYPE: {agent_type.strip()}")
+    if (job or "").strip():
+        meta_bits.append(f"MAIN JOB: {job.strip()}")
+    meta = ("\n".join(meta_bits) + "\n") if meta_bits else ""
+    return (
+        REGENERATE_INSTRUCTION
+        .replace("__META__", meta)
+        .replace("__FEEDBACK__", (feedback or "").strip() or "(none — just improve quality)")
+        .replace("__PROMPT__", (system_prompt or "").strip())
+    )
+
+
+def parse_generation(model_output: str) -> dict:
+    """Parse a generate/regenerate model reply into ``{system_prompt, variables}``.
+
+    Placeholders present in the produced prompt are authoritative for the variable
+    LIST (so prompt ↔ schema can't drift); the model's ``variables`` array only
+    supplies each one's label/description/type. Tolerant of fences/prose.
+    """
+    from sdk.agents.prompt_vars import extract_variables
+
+    data = _extract_json(model_output)
+    system_prompt = str(data.get("system_prompt", "")).strip() if isinstance(data, dict) else ""
+
+    meta: dict[str, dict] = {}
+    for v in (data.get("variables", []) if isinstance(data, dict) else []):
+        if isinstance(v, dict) and str(v.get("name", "")).strip():
+            meta[str(v["name"]).strip()] = v
+        elif isinstance(v, str) and v.strip():
+            meta[v.strip()] = {"name": v.strip()}
+
+    variables = []
+    for name in extract_variables(system_prompt):
+        m = meta.get(name, {})
+        vtype = str(m.get("type", "string")).strip() or "string"
+        variables.append({
+            "name": name,
+            "label": str(m.get("label") or name.replace("_", " ").title()).strip(),
+            "description": str(m.get("description", "")).strip(),
+            "type": vtype,
+        })
+    return {"system_prompt": system_prompt, "variables": variables}
+
+
 def _extract_json(model_output: str) -> dict:
     text = (model_output or "").strip()
     if "```" in text:

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.118}/sdk/client.py

@@ -59,7 +59,7 @@ def _notify_status(task_id: str, status: str) -> None:
             pass
 
 
-SDK_VERSION    = "1.4.116"
+from sdk import __version__ as SDK_VERSION   # single source: sdk/__init__.py
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
 _ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time
@@ -1119,6 +1119,89 @@ class BackendClient:
         _check_status(resp.status_code, self._base_url)
         return resp.json()
 
+    # ── Agent prompt generation ───────────────────────────────────────
+
+    async def generate_agent_prompt(
+        self,
+        agent_name: str,
+        agent_type: str,
+        job: str,
+        context: str = "",
+    ) -> dict:
+        """POST /api/v1/agent-prompt/generate — draft a system prompt for an agent.
+
+        Given the agent's ``name``, ``type``, and main ``job`` (plain language), the
+        backend returns a structured system prompt (Role/Objective/Rules/Workflow/
+        Output) with ``{{variable}}`` placeholders for any runtime inputs, plus the
+        extracted variable list. Shape::
+
+            {"agent_name": str, "agent_type": str, "system_prompt": str,
+             "variables": [{"name","label","description","type"}], "model": str}
+
+        The ``{{variable}}`` convention matches ``sdk.agents.prompt_vars`` so the
+        result feeds straight into the no-code builder / Prompt Studio.
+        """
+        url = self._url("/api/v1/agent-prompt/generate")
+        payload = {
+            "agent_name": agent_name,
+            "agent_type": agent_type,
+            "job": job,
+            "context": context,
+        }
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            resp = await client.post(url, json=payload, headers=self._headers)
+        if resp.status_code == 404:
+            raise BackendFeatureMissing("Agent prompt generation", url)
+        _check_status(resp.status_code, self._base_url)
+        return resp.json()
+
+    async def regenerate_agent_prompt(
+        self,
+        system_prompt: str,
+        feedback: str = "",
+        agent_name: str = "",
+        agent_type: str = "",
+        job: str = "",
+    ) -> dict:
+        """POST /api/v1/agent-prompt/regenerate — improve an existing prompt.
+
+        Same response shape as :meth:`generate_agent_prompt`. ``feedback`` steers
+        the rewrite; ``agent_name``/``agent_type``/``job`` are optional context.
+        """
+        url = self._url("/api/v1/agent-prompt/regenerate")
+        payload = {
+            "system_prompt": system_prompt,
+            "feedback": feedback,
+            "agent_name": agent_name,
+            "agent_type": agent_type,
+            "job": job,
+        }
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            resp = await client.post(url, json=payload, headers=self._headers)
+        if resp.status_code == 404:
+            raise BackendFeatureMissing("Agent prompt regeneration", url)
+        _check_status(resp.status_code, self._base_url)
+        return resp.json()
+
+    async def verify_agent_prompt(self, system_prompt: str) -> dict:
+        """POST /api/v1/agent-prompt/verify — manual-trigger verification.
+
+        For prompts a user wrote by hand: checks the prompt against our standards
+        (Role/Objective/Rules/Workflow/Output) and extracts variables + secrets for
+        the next builder step. Shape::
+
+            {"valid": bool, "missing_required": [...], "missing_recommended": [...],
+             "variables": [{"name","label","description","type"}],
+             "secrets": [{"name","description"}]}
+        """
+        url = self._url("/api/v1/agent-prompt/verify")
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            resp = await client.post(url, json={"system_prompt": system_prompt}, headers=self._headers)
+        if resp.status_code == 404:
+            raise BackendFeatureMissing("Agent prompt verification", url)
+        _check_status(resp.status_code, self._base_url)
+        return resp.json()
+
     # ── Custom agents ─────────────────────────────────────────────────
 
     async def register_custom_agent(self, manifest: dict) -> dict:

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.118}/sdk/config.py

@@ -13,6 +13,7 @@ import base64
 import hashlib
 import os
 import platform
+import re
 import sys
 from pathlib import Path
 from typing import Any
@@ -122,6 +123,73 @@ def get_base_url() -> str:
     return load().get("base_url", AI_DEFAULT_URL)
 
 
+def _dotenv_value(key: str) -> str:
+    """Read ``key`` from a ``.env`` file — dependency-free (no python-dotenv).
+
+    Looks in ``~/.agentos/.env`` first (where AgentOS lives on the VPS), then a
+    ``.env`` in the current working directory. Returns "" if not found. Values may
+    be quoted; surrounding quotes are stripped.
+    """
+    for path in (_CONFIG_DIR / ".env", Path.cwd() / ".env"):
+        try:
+            if not path.exists():
+                continue
+            for line in path.read_text().splitlines():
+                line = line.strip()
+                if not line or line.startswith("#") or "=" not in line:
+                    continue
+                k, _, v = line.partition("=")
+                if k.strip() == key:
+                    return v.strip().strip('"').strip("'")
+        except Exception:  # noqa: BLE001 — a malformed .env must never break startup
+            continue
+    return ""
+
+
+def _parse_ip_list(raw: str) -> list[str]:
+    """Split an IP allowlist string, tolerant of JSON-ish list syntax.
+
+    Accepts ``"1.2.3.4, 5.6.7.8"``, ``1.2.3.4 5.6.7.8``, or ``["1.2.3.4","5.6.7.8"]``.
+    """
+    raw = (raw or "").strip().strip("[]")
+    out: list[str] = []
+    for token in re.split(r"[,\s]+", raw):
+        ip = token.strip().strip('"').strip("'")
+        if ip and ip not in out:
+            out.append(ip)
+    return out
+
+
+def get_allowed_ips() -> list[str]:
+    """Client IPs permitted to reach the ``agentos-ui`` API (``/api/ui/*``).
+
+    This is the allowlist for the *inbound* half of the two-way link: the AI
+    backend (and only it) may call back into the SDK server. Loopback is always
+    trusted separately — this list is for the AI-backend IP(s) you whitelist.
+
+    Sources, merged (all optional), each accepting a comma/space-separated or
+    bracketed list of strings:
+      - ``.env`` key ``AGENTOS_UI_ALLOWED_IPS`` (``~/.agentos/.env`` or CWD ``.env``)
+      - process env ``AGENTOS_UI_ALLOWED_IPS``
+      - config.toml key ``allowed_ips``
+
+    Returns a de-duplicated list (empty means "loopback only"). Supplying the
+    AI-backend IP here later is all that's needed to open the link — no code
+    change. CIDR/prefix entries are supported by the middleware.
+    """
+    sources = [
+        _dotenv_value("AGENTOS_UI_ALLOWED_IPS"),
+        os.environ.get("AGENTOS_UI_ALLOWED_IPS", ""),
+        _load_raw().get("allowed_ips", ""),
+    ]
+    out: list[str] = []
+    for src in sources:
+        for ip in _parse_ip_list(src):
+            if ip not in out:
+                out.append(ip)
+    return out
+
+
 def get_branch_name_template() -> str | None:
     """Org-wide branch-naming convention, if configured in config.toml.
 

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.118}/sdk/ui/api.py

@@ -837,6 +837,122 @@ async def prompt_run(body: dict) -> dict:
     return {"job_id": jobs.start(work())}
 
 
+# ── Agent prompt generation (claude_code engine, runs LOCALLY on this VPS) ───
+# The AI backend calls these over the IP-allowlisted /api/ui surface; the response
+# is produced by the user's own authenticated `claude` CLI on this machine — no
+# server-side LLM. Synchronous (server-to-server): the caller awaits the result.
+
+async def _run_prompt_engine(prompt: str) -> str:
+    """Run Claude Code locally for a pure text/JSON authoring task, return its text."""
+    from pathlib import Path
+
+    from sdk.local_exec import run_claude_local
+
+    result = await run_claude_local(
+        prompt, str(Path.home() / ".agentos"), allowed_tools=["Read"],
+    )
+    if not result.get("ok"):
+        raise HTTPException(status_code=502, detail=result.get("error") or "generation failed")
+    return result.get("result", "") or ""
+
+
+@router.post("/agent-prompt/generate", dependencies=[_auth])
+async def agent_prompt_generate(body: dict) -> 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}``.
+    """
+    from sdk.agents.prompt_studio import build_generate_prompt, parse_generation
+
+    agent_name = str(body.get("agent_name", "")).strip()
+    agent_type = str(body.get("agent_type", "")).strip()
+    job = str(body.get("job", "")).strip()
+    if not agent_name or not agent_type or not job:
+        raise HTTPException(status_code=400, detail="agent_name, agent_type, and job are required.")
+
+    text = await _run_prompt_engine(
+        build_generate_prompt(agent_name, agent_type, job, str(body.get("context", "")))
+    )
+    parsed = parse_generation(text)
+    if not parsed["system_prompt"]:
+        raise HTTPException(status_code=502, detail="generation returned no system_prompt")
+    return {"agent_name": agent_name, "agent_type": agent_type, "engine": "claude_code", **parsed}
+
+
+@router.post("/agent-prompt/regenerate", dependencies=[_auth])
+async def agent_prompt_regenerate(body: dict) -> 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.
+    """
+    from sdk.agents.prompt_studio import build_regenerate_prompt, parse_generation
+
+    system_prompt = str(body.get("system_prompt", "")).strip()
+    if not system_prompt:
+        raise HTTPException(status_code=400, detail="system_prompt is required.")
+
+    text = await _run_prompt_engine(build_regenerate_prompt(
+        system_prompt, str(body.get("feedback", "")),
+        str(body.get("agent_name", "")), str(body.get("agent_type", "")), str(body.get("job", "")),
+    ))
+    parsed = parse_generation(text)
+    if not parsed["system_prompt"]:
+        raise HTTPException(status_code=502, detail="regeneration returned no system_prompt")
+    return {"agent_name": str(body.get("agent_name", "")).strip(),
+            "agent_type": str(body.get("agent_type", "")).strip(),
+            "engine": "claude_code", **parsed}
+
+
+@router.post("/agent-prompt/verify", dependencies=[_auth])
+async def agent_prompt_verify(body: dict) -> dict:
+    """Manual-trigger flow: verify a user-written prompt, then extract vars + secrets.
+
+    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[]}``.
+    """
+    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
+
+    system_prompt = str(body.get("system_prompt", "")).strip()
+    if len(system_prompt) < 10:
+        raise HTTPException(status_code=400, detail="Write a system prompt first (a bit longer).")
+
+    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
+
+    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",
+        })
+
+    return {
+        "valid": not standards["missing_required"],
+        "missing_required": standards["missing_required"],
+        "missing_recommended": standards["missing_recommended"],
+        "variables": variables,
+        "secrets": analysis.get("secrets", []),
+        "engine": "claude_code",
+    }
+
+
 @router.get("/agents/form", dependencies=[_auth])
 async def agent_form(name: str = Query(...)) -> dict:
     """The saved Studio form (inputs/outputs/tools) for an agent, if any."""

devops_bot_sdk-1.4.118/sdk/ui/ip_allowlist.py

@@ -0,0 +1,110 @@
+"""IP allowlist for the ``agentos-ui`` server — the inbound half of the two-way link.
+
+The ENTIRE server (including ``/docs``, ``/openapi.json``, ``/healthz``, the panel
+UI, and every ``/api/ui/*`` call) is reachable ONLY from:
+  - the machine it runs on — loopback (127.0.0.0/8, ::1) AND the host's own IP
+    addresses, so hitting it via the box's public IP works too;
+  - any IP/CIDR in ``AGENTOS_UI_ALLOWED_IPS`` or the config.toml ``allowed_ips``
+    key (see ``sdk.config.get_allowed_ips``) — i.e. the AI-backend IP you whitelist.
+
+Every other client gets ``403`` for every path — nothing is public.
+
+Behind a reverse proxy the direct peer is the proxy, not the real client. Set
+``AGENTOS_UI_TRUST_FORWARDED_FOR=1`` to instead honour the left-most
+``X-Forwarded-For`` entry — enable ONLY when a trusted proxy sets that header,
+since clients can otherwise spoof it.
+"""
+from __future__ import annotations
+
+import ipaddress
+import os
+import socket
+
+
+def _loopback(ip: ipaddress._BaseAddress) -> bool:
+    return ip.is_loopback
+
+
+def _parse(value: str):
+    """Parse an IP or CIDR string into a network, or None if malformed."""
+    value = (value or "").strip()
+    if not value:
+        return None
+    try:
+        # strict=False so a bare host like "10.0.0.5" or "10.0.0.0/24" both work.
+        return ipaddress.ip_network(value, strict=False)
+    except ValueError:
+        return None
+
+
+def _local_ips() -> set[str]:
+    """Best-effort set of THIS host's own IP addresses.
+
+    Lets the box reach the server through its own public/LAN IP (not just
+    127.0.0.1) — "the system where it is installed" — without whitelisting it.
+    """
+    ips: set[str] = set()
+    try:
+        for info in socket.getaddrinfo(socket.gethostname(), None):
+            ips.add(info[4][0])
+    except Exception:  # noqa: BLE001
+        pass
+    # The primary outbound IP (covers the usual public/LAN address even when the
+    # hostname doesn't resolve to it).
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        ips.add(s.getsockname()[0])
+        s.close()
+    except Exception:  # noqa: BLE001
+        pass
+    return ips
+
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+
+class IPAllowlistMiddleware(BaseHTTPMiddleware):
+    """Reject EVERY request from clients that aren't loopback, this host, or allowlisted."""
+
+    def __init__(self, app, allowed: list[str] | None = None) -> None:
+        super().__init__(app)
+        # Resolve the allowlist once at startup. Callers can pass an explicit list
+        # (tests); otherwise we read env + config.toml.
+        if allowed is None:
+            try:
+                from sdk.config import get_allowed_ips
+                allowed = get_allowed_ips()
+            except Exception:  # noqa: BLE001 — never let config break the server
+                allowed = []
+        # Configured allowlist + this host's own IPs, all as networks.
+        entries = list(allowed) + list(_local_ips())
+        self._networks = [n for n in (_parse(a) for a in entries) if n is not None]
+        self._trust_xff = os.environ.get("AGENTOS_UI_TRUST_FORWARDED_FOR", "") in ("1", "true", "TRUE", "yes")
+
+    def _client_ip(self, request: Request) -> str:
+        if self._trust_xff:
+            xff = request.headers.get("x-forwarded-for", "")
+            if xff:
+                return xff.split(",")[0].strip()
+        return (request.client.host if request.client else "") or ""
+
+    def _permitted(self, raw_ip: str) -> bool:
+        try:
+            ip = ipaddress.ip_address(raw_ip)
+        except ValueError:
+            return False
+        if _loopback(ip):
+            return True
+        return any(ip in net for net in self._networks)
+
+    async def dispatch(self, request: Request, call_next):
+        # Guard EVERY path — nothing on this server is public.
+        if not self._permitted(self._client_ip(request)):
+            return JSONResponse(
+                {"detail": "Your IP is not allowed to access this server."},
+                status_code=403,
+            )
+        return await call_next(request)

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.118}/sdk/ui/security.py

@@ -44,8 +44,15 @@ def token_matches(candidate: str | None) -> bool:
 def extract_token(headers, query_params) -> str | None:
     """Pull the token from an Authorization/X-header or the ?token= query param."""
     auth = headers.get("authorization") or headers.get("Authorization")
-    if auth and auth.lower().startswith("bearer "):
-        return auth[7:].strip()
+    if auth:
+        a = auth.strip()
+        if a.lower().startswith("bearer "):
+            return a[7:].strip()
+        # Raw ``co_<uuid>_<hex>`` apiTokenHash with no ``Bearer`` prefix — the form
+        # BackendClient and the devops-bot-ai proxy send. Accept it directly so the
+        # same token works against both the AI backend and this SDK server.
+        if a.startswith("co_"):
+            return a
     hdr = headers.get("x-agentos-ui-token") or headers.get("X-AgentOS-UI-Token")
     if hdr:
         return hdr.strip()

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.118}/sdk/ui/server.py

@@ -29,8 +29,17 @@ def create_app():
 
     from sdk.ui import dashboard
     from sdk.ui.api import router as api_router
-
-    app = FastAPI(title="AgentOS Control Panel", docs_url=None, redoc_url=None)
+    from sdk.ui.ip_allowlist import IPAllowlistMiddleware
+
+    # Swagger at /docs (ReDoc /redoc, schema /openapi.json). NOTE: the whole server
+    # — docs included — is locked by the IP allowlist below; only this host and
+    # whitelisted IPs can reach ANY path (data calls also need the access token).
+    from sdk import __version__ as _sdk_version
+    app = FastAPI(title="AgentOS SDK", version=_sdk_version, docs_url="/docs", redoc_url="/redoc")
+    # Inbound half of the two-way link: 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.
+    app.add_middleware(IPAllowlistMiddleware)
     app.include_router(api_router)
 
     @app.get("/")
@@ -133,7 +142,11 @@ def main() -> None:
             pass
 
     import uvicorn
-    uvicorn.run(create_app(), host=args.host, port=args.port, log_level="warning")
+    # proxy_headers=False: the IP allowlist must decide on the REAL TCP peer, not a
+    # client-supplied X-Forwarded-For. XFF is honoured only when the operator opts
+    # in via AGENTOS_UI_TRUST_FORWARDED_FOR (handled in IPAllowlistMiddleware).
+    uvicorn.run(create_app(), host=args.host, port=args.port,
+                log_level="warning", proxy_headers=False)
 
 
 if __name__ == "__main__":