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

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

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

@@ -16,6 +16,7 @@ sdk/exceptions.py
 sdk/git_ops.py
 sdk/graphify.py
 sdk/local_exec.py
+sdk/platform_compat.py
 sdk/py.typed
 sdk/run_auto.py
 sdk/sse.py
@@ -66,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.116 → 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.116"
+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.116 → 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.116
+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.116"
-__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.116 → devops_bot_sdk-1.4.118}/sdk/agentd.py

@@ -618,6 +618,12 @@ def status() -> None:
 
 
 def main() -> None:
+    # macOS: keep the background daemon from aborting ("Python quit unexpectedly")
+    # when it does networking after the double-fork. May re-exec once; must run
+    # before any fork or objc-linked import.
+    from sdk.platform_compat import ensure_macos_fork_safety
+    ensure_macos_fork_safety()
+
     argv = sys.argv[1:]
     if argv and argv[0] == "start":
         foreground = "--foreground" in argv[1:] or "-f" in argv[1:]

{devops_bot_sdk-1.4.116 → 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.116 → 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.116 → 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.118/sdk/platform_compat.py

@@ -0,0 +1,48 @@
+"""Cross-platform runtime shims used by the CLI entry points.
+
+Kept dependency-free and import-cheap: these run at the very top of ``main()``
+BEFORE any networking/objc-linked module is imported, and one of them re-execs
+the interpreter — so it must not drag in heavy imports of its own.
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+
+def ensure_macos_fork_safety() -> None:
+    """Stop macOS from killing our background daemons with a native abort.
+
+    ``agentos-auto`` / ``agentos-agentd`` double-fork (fork + setsid, no exec)
+    into a background daemon that then does networking (httpx → CFNetwork /
+    SystemConfiguration) and TLS. When the Objective-C runtime detects objc use
+    after a bare ``fork()`` with no ``exec()`` it calls ``abort()`` — which macOS
+    surfaces as the "Python quit unexpectedly" crash dialog. Exporting
+    ``OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES`` disables that guard.
+
+    The objc runtime reads that variable when its dylib is first mapped (that is
+    interpreter startup on framework Python builds), so setting it via
+    ``os.environ`` mid-run is too late to help the CURRENT process. We set it and
+    re-exec a FRESH interpreter ONCE, so the replacement process — and every
+    daemon it later forks — starts with the variable already in place. We also
+    short-circuit the system-proxy (``_scproxy``) lookup that most often triggers
+    the objc path on the first outbound request.
+
+    No-op off macOS, and idempotent: the "already YES" check is the re-exec guard
+    that prevents an exec loop.
+    """
+    if sys.platform != "darwin":
+        return
+    if os.environ.get("OBJC_DISABLE_INITIALIZE_FORK_SAFETY") == "YES":
+        return  # already applied on this process → don't re-exec again
+    os.environ["OBJC_DISABLE_INITIALIZE_FORK_SAFETY"] = "YES"
+    os.environ.setdefault("no_proxy", "*")
+    try:
+        # os.execv inherits the just-modified os.environ, so the fresh process
+        # sees the variable from its first instruction. argv[0] is a runnable
+        # Python file for both a console-script launch and `python -m ...`.
+        os.execv(sys.executable, [sys.executable, sys.argv[0], *sys.argv[1:]])
+    except Exception:  # noqa: BLE001
+        # Re-exec failed (unusual argv[0], permissions). The env var is at least
+        # set for child processes we spawn — carry on rather than refuse to start.
+        pass

{devops_bot_sdk-1.4.116 → devops_bot_sdk-1.4.118}/sdk/run_auto.py

@@ -544,6 +544,12 @@ def _run_loop(workspace_root: str | None, only_keys: list[str] | None = None,
 
 
 def main() -> None:
+    # macOS: keep the background daemon from aborting ("Python quit unexpectedly")
+    # when it does networking after the double-fork. May re-exec once; must run
+    # before any fork or objc-linked import.
+    from sdk.platform_compat import ensure_macos_fork_safety
+    ensure_macos_fork_safety()
+
     argv = sys.argv[1:]
     cmd = argv[0] if argv and not argv[0].startswith("-") else "run"
 

{devops_bot_sdk-1.4.116 → 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.116 → 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.116 → 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__":

{devops_bot_sdk-1.4.116 → devops_bot_sdk-1.4.118}/sdk/ui/static/app.js

@@ -225,7 +225,7 @@
     let toolsNeeded = [];   // AI-assessed; the user never sees or sets these
     let lastInputs = [];    // input DEFINITIONS from analyze/manual-add (for saving)
     let lastOutputs = [];
-    let lastSecrets = [];   // API-key names detected by analyze (values collected at save)
+    let lastSecrets = [];   // API-key names (analyze-detected or hand-added; values collected at save)
     let studioJob = null;   // id of the in-flight analyze/review/run job
 
     function showStop(on) {
@@ -276,17 +276,30 @@
       $("save-panel").style.display = "";
     }
 
-    // Required API keys detected by analyze — collected here, stored (encrypted)
-    // when the agent is saved. Values are password inputs; names are fixed.
+    // Department defaults resolve their keys from the backend/host env, not a local
+    // store — so the value inputs are irrelevant (and hidden) in that scope.
+    function secretsHidden() {
+      return $("sa-scope") && $("sa-scope-field").style.display !== "none"
+        && $("sa-scope").value === "department";
+    }
+    // One secret row: env-var name (+ optional description) + masked value + remove.
+    function secretRowHTML(s, value) {
+      const desc = s.description ? ` <span class="muted" style="font-weight:400">— ${esc(s.description)}</span>` : "";
+      return `<div class="field" data-secret-row="${esc(s.name)}"><label>${esc(s.name)}${desc}` +
+        ` <a href="#" class="secret-rm" data-rmsecret="${esc(s.name)}" style="margin-left:6px;font-weight:400;font-size:12px">remove</a></label>` +
+        `<input class="secret-in" type="password" data-secret="${esc(s.name)}" placeholder="paste value (optional — hidden)" autocomplete="off" value="${esc(value || "")}" /></div>`;
+    }
+    // API keys detected by analyze OR added by hand — collected here, stored
+    // (encrypted) when the agent is saved. Shown once analysis has run so the user
+    // can add a key even when the AI detected none.
     function renderSecrets() {
       const panel = $("studio-secrets-panel"), box = $("studio-secrets");
       if (!panel || !box) return;
-      if (!lastSecrets.length) { panel.style.display = "none"; box.innerHTML = ""; return; }
+      if (secretsHidden()) { panel.style.display = "none"; return; }
       panel.style.display = "";
-      box.innerHTML = lastSecrets.map(s =>
-        `<div class="field"><label>${esc(s.name)}${s.description ? ` <span class="muted" style="font-weight:400">— ${esc(s.description)}</span>` : ""}</label>
-           <input class="secret-in" type="password" data-secret="${esc(s.name)}" placeholder="paste value (optional — hidden)" autocomplete="off" /></div>`
-      ).join("");
+      box.innerHTML = lastSecrets.length
+        ? lastSecrets.map(s => secretRowHTML(s, "")).join("")
+        : "<div class='muted' data-empty>No API keys detected — add one below if this task calls an external service.</div>";
     }
 
     function collectSecrets() {
@@ -391,6 +404,35 @@
       $("studio-inputs").appendChild(wrap.firstChild);
     });
 
+    // Let the user add an API key the AI missed. Names are env-var style
+    // (UPPER_SNAKE); the value is optional here and can be filled in later.
+    $("sp-add-secret").addEventListener("click", () => {
+      const raw = (window.prompt("Environment-variable NAME for this key (e.g. OPENAI_API_KEY):") || "").trim();
+      if (!raw) return;
+      const name = raw.toUpperCase().replace(/[^A-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
+      if (!name) { toast("Use an env-var name like OPENAI_API_KEY", "err"); return; }
+      if (lastSecrets.some(s => s.name === name)) { toast("That secret already exists", "err"); return; }
+      const desc = (window.prompt("What is it for? (optional)") || "").trim();
+      lastSecrets.push({ name, description: desc });
+      const empty = $("studio-secrets").querySelector("[data-empty]");
+      if (empty) empty.remove();
+      const wrap = document.createElement("div");
+      wrap.innerHTML = secretRowHTML({ name, description: desc }, "");
+      $("studio-secrets").appendChild(wrap.firstChild);
+    });
+
+    // Drop a secret (AI-detected over-reach or one added by mistake).
+    $("studio-secrets").addEventListener("click", (e) => {
+      const a = e.target.closest(".secret-rm");
+      if (!a) return;
+      e.preventDefault();
+      const nm = a.dataset.rmsecret;
+      lastSecrets = lastSecrets.filter(s => s.name !== nm);
+      const row = $("studio-secrets").querySelector(`[data-secret-row="${nm}"]`);
+      if (row) row.remove();
+      if (!lastSecrets.length) renderSecrets();   // restore the "add one below" hint
+    });
+
     async function pollRunInto(promise) {
       $("sp-run-status").textContent = "Running… (safe to switch pages — it keeps running)";
       $("resp-panel").style.display = "";
@@ -440,9 +482,8 @@
     // when that scope is picked (they resolve keys from the backend/host env).
     if ($("sa-scope")) $("sa-scope").addEventListener("change", () => {
       const panel = $("studio-secrets-panel");
-      if (panel && lastSecrets.length) {
-        panel.style.display = $("sa-scope").value === "department" ? "none" : "";
-      }
+      if (!panel || $("io-panel").style.display === "none") return;  // only after analysis
+      panel.style.display = secretsHidden() ? "none" : "";
     });
 
     // Turn this Studio session into a reusable agent (custom or department default).

{devops_bot_sdk-1.4.116 → devops_bot_sdk-1.4.118}/sdk/ui/static/prompt-studio.html

@@ -43,12 +43,13 @@
         <button class="btn" id="sp-add-input" type="button" style="margin-top:6px">+ Add input</button>
 
         <div id="studio-secrets-panel" style="display:none;margin-top:14px">
-          <div style="font-weight:600;margin-bottom:2px">API keys required <span class="muted" style="font-weight:400">(detected by AI)</span></div>
+          <div style="font-weight:600;margin-bottom:2px">API keys &amp; secrets <span class="muted" style="font-weight:400">(detected by AI — add any it missed)</span></div>
           <p class="muted" style="margin:0 0 .5em;font-size:12px">
             Stored <b>encrypted on this machine</b> when you save the agent, reused every run.
-            Leave blank to fill in later on the Custom Agents page.
+            Leave a value blank to fill in later on the Custom Agents page.
           </p>
           <div id="studio-secrets"></div>
+          <button class="btn" id="sp-add-secret" type="button" style="margin-top:6px">+ Add secret</button>
         </div>
         <div style="margin-top:10px">
           <button class="btn primary" id="sp-run">Run</button>