devops-bot-sdk 1.4.125__tar.gz → 1.4.129__tar.gz

{devops_bot_sdk-1.4.125 → devops_bot_sdk-1.4.129}/PKG-INFO

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

{devops_bot_sdk-1.4.125 → devops_bot_sdk-1.4.129}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.125 → devops_bot_sdk-1.4.129}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -69,6 +69,7 @@ sdk/ui/api.py
 sdk/ui/dashboard.py
 sdk/ui/ip_allowlist.py
 sdk/ui/jobs.py
+sdk/ui/models.py
 sdk/ui/runner.py
 sdk/ui/security.py
 sdk/ui/server.py

{devops_bot_sdk-1.4.125 → devops_bot_sdk-1.4.129}/sdk/__init__.py

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

@@ -565,6 +565,17 @@ def main() -> None:
         after = current_version()
         if after != before:
             print(f"✓ updated {before} → {after}")
+            # Reload the control-panel server so newly-added /api/ui/* routes take
+            # effect — a running server keeps the code it imported at boot. Only
+            # restarts a managed (systemd/launchd/schtask) service; a manually-run
+            # panel is left alone with a hint.
+            try:
+                from sdk.ui import service as ui_service
+                ok, msg = ui_service.restart()
+                print(f"  control panel: {msg}" if ok
+                      else f"  control panel: not reloaded — {msg}")
+            except Exception as exc:  # noqa: BLE001 — never fail the update on this
+                print(f"  control panel: not reloaded ({exc})")
             pid = _daemon_running()
             if pid:
                 print("note: a background loop is running the OLD version — "

{devops_bot_sdk-1.4.125 → devops_bot_sdk-1.4.129}/sdk/ui/api.py

@@ -7,10 +7,29 @@ and ``sdk.config`` — no business logic is reimplemented here.
 """
 from __future__ import annotations
 
-from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from fastapi import APIRouter, Depends, HTTPException, Query, Request, Security
 from fastapi.responses import StreamingResponse
+from fastapi.security import APIKeyHeader
 
 from sdk.ui import dashboard, runner, security, setup_manager
+from sdk.ui.models import (
+    AgentChatRequest,
+    AgentKeysSet,
+    AgentPromptGenerateRequest,
+    AgentRunRequest,
+    AllowlistEntry,
+    ConfigureRequest,
+    PromptRegenerateRequest,
+    PromptRunRequest,
+    PromptVerifyRequest,
+    SetupRequest,
+    StoryRequest,
+    SystemChatRequest,
+    SystemPromptRequest,
+    TicketRequest,
+    UpdateAgentRequest,
+    WorkspaceRequest,
+)
 
 router = APIRouter(prefix="/api/ui")
 
@@ -19,10 +38,25 @@ router = APIRouter(prefix="/api/ui")
 
 _LOOPBACK = {"127.0.0.1", "::1", "localhost"}
 
-
-async def require_token(request: Request) -> None:
+# Declared PURELY so Swagger renders an "Authorize" box — paste your own co_ token
+# there (nothing is ever pre-filled server-side). auto_error=False: loopback needs
+# no token, and the token may also arrive via ?token= (SSE) or X-AgentOS-UI-Token,
+# so the scheme documents the header without owning enforcement — that stays below.
+_token_scheme = APIKeyHeader(
+    name="Authorization",
+    scheme_name="co_token",
+    auto_error=False,
+    description="Your DevOpsBot API token — paste the raw co_… value (or 'Bearer co_…').",
+)
+
+
+async def require_token(
+    request: Request,
+    _scheme: str | None = Security(_token_scheme),
+) -> None:
     # Same-machine (loopback) access is trusted — no token needed. Remote access
-    # must present the configured co_ API token.
+    # must present the configured co_ API token. (``_scheme`` only wires the
+    # Swagger Authorize box; the actual token is read below to cover all forms.)
     host = (request.client.host if request.client else "") or ""
     if host in _LOOPBACK:
         return
@@ -66,15 +100,6 @@ async def status() -> dict:
 # middleware re-reads it per request so a new IP works immediately (no restart).
 # The backend proxies here (POST /api/v1/sdk/whitelist-ip) to open access for an IP.
 
-def _valid_ip_or_cidr(value: str) -> bool:
-    import ipaddress
-    try:
-        ipaddress.ip_network(value, strict=False)
-        return True
-    except ValueError:
-        return False
-
-
 @router.get("/allowlist", dependencies=[_auth])
 async def get_allowlist() -> dict:
     """This SDK's allowlist, split into permanent vs runtime.
@@ -93,20 +118,17 @@ async def get_allowlist() -> dict:
 
 
 @router.post("/allowlist", dependencies=[_auth])
-async def add_to_allowlist(body: dict) -> dict:
+async def add_to_allowlist(body: AllowlistEntry) -> dict:
     """Whitelist an IP/CIDR for this SDK at runtime. Body: ``{ip}``. Idempotent.
 
     Opens the IP gate for that client across every path (all endpoints + UI + docs)
     until it's disabled. Effective immediately (the middleware re-reads per request).
+    The ``ip`` field is validated (IPv4/IPv6 address or CIDR) by ``AllowlistEntry``;
+    a malformed or missing value returns 422 before this handler runs.
     """
     from sdk.config import add_allowed_ip
 
-    ip = str(body.get("ip", "")).strip()
-    if not ip:
-        raise HTTPException(status_code=400, detail="ip is required.")
-    if not _valid_ip_or_cidr(ip):
-        raise HTTPException(status_code=400, detail=f"invalid IP or CIDR: {ip!r}")
-    return {"added": ip, "allowed_ips": add_allowed_ip(ip)}
+    return {"added": body.ip, "allowed_ips": add_allowed_ip(body.ip)}
 
 
 @router.delete("/allowlist", dependencies=[_auth])
@@ -121,20 +143,17 @@ async def remove_from_allowlist(ip: str = Query(...)) -> dict:
 
 
 @router.post("/configure", dependencies=[_auth])
-async def configure(body: dict) -> dict:
+async def configure(body: ConfigureRequest) -> dict:
     from sdk import config as sdk_config
 
-    token = str(body.get("token", "")).strip()
-    if not token.startswith("co_"):
-        raise HTTPException(status_code=400, detail="Token must start with 'co_'.")
-    sdk_config.save(sdk_config.get_base_url(), token)
+    sdk_config.save(sdk_config.get_base_url(), body.token)
     ok, message = await dashboard.validate_token()
     return {"saved": True, "connected": ok, "message": message}
 
 
 @router.post("/setup", dependencies=[_auth])
-async def setup(body: dict | None = None) -> StreamingResponse:
-    upgrade = bool((body or {}).get("upgrade", True))
+async def setup(body: SetupRequest | None = None) -> StreamingResponse:
+    upgrade = (body or SetupRequest()).upgrade
 
     async def gen():
         async for chunk in setup_manager.reinstall_sdk(upgrade=upgrade):
@@ -168,44 +187,34 @@ async def restart_loop() -> dict:
 # ── Execution (one per agentos-auto subcommand) ────────────────────────────
 
 @router.post("/run", dependencies=[_auth])
-async def run(body: dict | None = None) -> dict:
+async def run(body: WorkspaceRequest | None = None) -> dict:
     args = ["run"]
-    root = (body or {}).get("workspace_root")
+    root = (body or WorkspaceRequest()).workspace_root
     if root:
-        args += ["--workspace-root", str(root)]
+        args += ["--workspace-root", root]
     return runner.spawn_auto(*args)
 
 
 @router.post("/resume", dependencies=[_auth])
-async def resume(body: dict | None = None) -> dict:
+async def resume(body: WorkspaceRequest | None = None) -> dict:
     args = ["resume"]
-    root = (body or {}).get("workspace_root")
+    root = (body or WorkspaceRequest()).workspace_root
     if root:
-        args += ["--workspace-root", str(root)]
+        args += ["--workspace-root", root]
     return runner.spawn_auto(*args)
 
 
 @router.post("/ticket", dependencies=[_auth])
-async def ticket(body: dict) -> dict:
-    keys = body.get("keys") or []
-    if isinstance(keys, str):
-        keys = keys.split()
-    keys = [str(k).strip() for k in keys if str(k).strip()]
-    if not keys:
-        raise HTTPException(status_code=400, detail="Provide at least one ticket key.")
-    args = ["ticket", *keys]
-    root = body.get("workspace_root")
-    if root:
-        args += ["--workspace-root", str(root)]
+async def ticket(body: TicketRequest) -> dict:
+    args = ["ticket", *body.keys]
+    if body.workspace_root:
+        args += ["--workspace-root", body.workspace_root]
     return runner.spawn_auto(*args)
 
 
 @router.post("/story", dependencies=[_auth])
-async def story(body: dict | None = None) -> dict:
-    keys = (body or {}).get("keys") or []
-    if isinstance(keys, str):
-        keys = keys.split()
-    keys = [str(k).strip() for k in keys if str(k).strip()]
+async def story(body: StoryRequest | None = None) -> dict:
+    keys = (body or StoryRequest()).keys
     return runner.spawn_auto("story", *keys)
 
 
@@ -410,7 +419,7 @@ async def agent_keys_list(name: str = Query(...)) -> dict:
 
 
 @router.post("/agents/keys", dependencies=[_auth])
-async def agent_keys_set(body: dict) -> dict:
+async def agent_keys_set(body: AgentKeysSet) -> dict:
     """Persist/update a custom agent's API keys (encrypted, local, per-agent).
 
     Body: ``name``, ``keys`` ({ENV_VAR: value}). Merge semantics — keys omitted
@@ -419,14 +428,10 @@ async def agent_keys_set(body: dict) -> dict:
     """
     from sdk.agents import secrets as agent_secrets
 
-    name = str(body.get("name", "")).strip()
-    keys = body.get("keys") or {}
-    if not name:
-        raise HTTPException(status_code=400, detail="name is required.")
-    if not isinstance(keys, dict) or not keys:
-        raise HTTPException(status_code=400, detail="keys must be a non-empty object.")
-    stored = agent_secrets.save_secrets(name, {str(k): str(v) for k, v in keys.items()}, merge=True)
-    return {"name": name, "keys": sorted(stored.keys())}
+    stored = agent_secrets.save_secrets(
+        body.name, {str(k): str(v) for k, v in body.keys.items()}, merge=True
+    )
+    return {"name": body.name, "keys": sorted(stored.keys())}
 
 
 @router.delete("/agents/keys", dependencies=[_auth])
@@ -500,7 +505,7 @@ async def job_cancel(job_id: str) -> dict:
 
 
 @router.patch("/agents", dependencies=[_auth])
-async def update_agent(body: dict) -> dict:
+async def update_agent(body: UpdateAgentRequest) -> dict:
     """Update a local custom agent (description / prompt / tools / enabled status).
 
     Re-validates and rewrites the local manifest, and best-effort syncs the change
@@ -510,20 +515,19 @@ async def update_agent(body: dict) -> dict:
 
     from sdk.agents.manifest import AGENTS_DIR, AgentManifest, load_agents
 
-    name = str(body.get("name", "")).strip()
-    if not name:
-        raise HTTPException(status_code=400, detail="name is required.")
+    name = body.name
+    sent = body.model_fields_set  # PATCH: only fields the caller sent are applied
     manifest = next((a for a in load_agents() if a.name == name), None)
     if manifest is None:
         raise HTTPException(status_code=404, detail=f"no local agent '{name}'")
 
     local_changes: dict = {}
-    if "description" in body:
-        local_changes["description"] = str(body.get("description") or "")
-    if "prompt" in body:
-        local_changes["prompt"] = str(body.get("prompt") or "")
-    if "allowed_tools" in body:
-        local_changes["allowed_tools"] = list(body.get("allowed_tools") or [])
+    if "description" in sent:
+        local_changes["description"] = str(body.description or "")
+    if "prompt" in sent:
+        local_changes["prompt"] = str(body.prompt or "")
+    if "allowed_tools" in sent:
+        local_changes["allowed_tools"] = list(body.allowed_tools or [])
 
     updated = None
     if local_changes:
@@ -536,7 +540,7 @@ async def update_agent(body: dict) -> dict:
             encoding="utf-8",
         )
 
-    status = str(body.get("status", "")).strip()
+    status = (body.status or "").strip()
     # Backend sync (best-effort). Agent CREATION/authoring is not owned by the SDK
     # anymore, so a content edit is applied LOCALLY only — no re-register upsert.
     # A status change still syncs to the backend (per-agent enable/disable).
@@ -577,7 +581,7 @@ async def delete_agent(name: str = Query(...)) -> dict:
 
 
 @router.post("/agents/chat", dependencies=[_auth])
-async def agent_chat(body: dict) -> dict:
+async def agent_chat(body: AgentChatRequest) -> dict:
     """Chat with an agent (runs its engine on this machine).
 
     Body: ``name``, ``message``, optional ``variables`` ({{var}} values), optional
@@ -587,13 +591,11 @@ async def agent_chat(body: dict) -> dict:
     """
     from sdk.ui import jobs
 
-    name = str(body.get("name", "")).strip()
-    message = str(body.get("message", "")).strip()
-    if not name or not message:
-        raise HTTPException(status_code=400, detail="name and message are required.")
-    variables = body.get("variables") or {}
-    history = body.get("history") or []
-    department_id = str(body.get("department_id", "")).strip()
+    name = body.name
+    message = body.message
+    variables = body.variables
+    history = body.history
+    department_id = body.department_id
 
     async def work() -> dict:
         import time as _time
@@ -621,7 +623,7 @@ async def agent_chat(body: dict) -> dict:
 
 
 @router.post("/agents/run", dependencies=[_auth])
-async def agent_run(body: dict) -> dict:
+async def agent_run(body: AgentRunRequest) -> dict:
     """Run an agent once with fresh ``{{variable}}`` values — no chat.
 
     Body: ``name``, ``variables`` ({{var}} → value; may differ every run),
@@ -633,12 +635,10 @@ async def agent_run(body: dict) -> dict:
     """
     from sdk.ui import jobs
 
-    name = str(body.get("name", "")).strip()
-    if not name:
-        raise HTTPException(status_code=400, detail="name is required.")
-    variables = body.get("variables") or {}
-    department_id = str(body.get("department_id", "")).strip()
-    scope = str(body.get("scope") or body.get("source") or "custom").strip() or "custom"
+    name = body.name
+    variables = body.variables
+    department_id = body.department_id
+    scope = body.scope
 
     async def work() -> dict:
         import time as _time
@@ -672,7 +672,7 @@ async def system_inventory() -> dict:
 
 
 @router.post("/system/chat", dependencies=[_auth])
-async def system_chat(body: dict) -> dict:
+async def system_chat(body: SystemChatRequest) -> dict:
     """Ask the System Assistant about agents, subagents, tools, plugins & usage.
 
     Grounds the local model in the live inventory JSON and answers the question.
@@ -681,10 +681,8 @@ async def system_chat(body: dict) -> dict:
     """
     from sdk.ui import jobs
 
-    message = str(body.get("message", "")).strip()
-    if not message:
-        raise HTTPException(status_code=400, detail="message is required.")
-    history = body.get("history") or []
+    message = body.message
+    history = body.history
 
     async def work() -> dict:
         from pathlib import Path
@@ -732,7 +730,7 @@ async def agent_prompt(name: str = Query(...)) -> dict:
 
 
 @router.post("/prompt/analyze", dependencies=[_auth])
-async def prompt_analyze(body: dict) -> dict:
+async def prompt_analyze(body: SystemPromptRequest) -> dict:
     """AI reads a system prompt and infers its input variables + output/format.
 
     Body: ``system_prompt``. Runs as a detached job (navigation-safe); poll
@@ -740,9 +738,7 @@ async def prompt_analyze(body: dict) -> dict:
     """
     from sdk.ui import jobs
 
-    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).")
+    system_prompt = body.system_prompt
 
     async def work() -> dict:
         from pathlib import Path
@@ -762,7 +758,7 @@ async def prompt_analyze(body: dict) -> dict:
 
 
 @router.post("/prompt/comments", dependencies=[_auth])
-async def prompt_comments(body: dict) -> dict:
+async def prompt_comments(body: SystemPromptRequest) -> dict:
     """AI reviews the system prompt and returns open questions as 'comments'.
 
     Resolve these by editing the prompt BEFORE building the agent — so the agent
@@ -771,9 +767,7 @@ async def prompt_comments(body: dict) -> dict:
     """
     from sdk.ui import jobs
 
-    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).")
+    system_prompt = body.system_prompt
 
     async def work() -> dict:
         from pathlib import Path
@@ -793,7 +787,7 @@ async def prompt_comments(body: dict) -> dict:
 
 
 @router.post("/prompt/run", dependencies=[_auth])
-async def prompt_run(body: dict) -> dict:
+async def prompt_run(body: PromptRunRequest) -> dict:
     """Run a system prompt with the user-supplied input values → the response.
 
     Body: ``system_prompt``, ``inputs`` ({name: value}), optional ``output_format``,
@@ -804,14 +798,12 @@ async def prompt_run(body: dict) -> dict:
     from sdk.agents.prompt_studio import sanitize_tools
     from sdk.ui import jobs
 
-    system_prompt = str(body.get("system_prompt", "")).strip()
-    if not system_prompt:
-        raise HTTPException(status_code=400, detail="system_prompt is required.")
-    inputs = body.get("inputs") or {}
-    output_format = str(body.get("output_format", "")).strip()
+    system_prompt = body.system_prompt
+    inputs = body.inputs
+    output_format = body.output_format
     # AI-assessed tools; fall back to a minimal read-only tool so a pure text task
     # never inherits the broad default allowlist.
-    tools = sanitize_tools(body.get("tools") or []) or ["Read"]
+    tools = sanitize_tools(body.tools) or ["Read"]
 
     async def work() -> dict:
         import time as _time
@@ -858,7 +850,7 @@ async def _run_prompt_engine(prompt: str) -> str:
 
 
 @router.post("/agent-prompt/generate", dependencies=[_auth])
-async def agent_prompt_generate(body: dict) -> dict:
+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``.
@@ -866,14 +858,12 @@ async def agent_prompt_generate(body: dict) -> dict:
     """
     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.")
+    agent_name = body.agent_name
+    agent_type = body.agent_type
+    job = body.job
 
     text = await _run_prompt_engine(
-        build_generate_prompt(agent_name, agent_type, job, str(body.get("context", "")))
+        build_generate_prompt(agent_name, agent_type, job, body.context)
     )
     parsed = parse_generation(text)
     if not parsed["system_prompt"]:
@@ -882,7 +872,7 @@ async def agent_prompt_generate(body: dict) -> dict:
 
 
 @router.post("/agent-prompt/regenerate", dependencies=[_auth])
-async def agent_prompt_regenerate(body: dict) -> dict:
+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``,
@@ -890,24 +880,20 @@ async def agent_prompt_regenerate(body: dict) -> dict:
     """
     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", "")),
+        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 {"agent_name": str(body.get("agent_name", "")).strip(),
-            "agent_type": str(body.get("agent_type", "")).strip(),
+    return {"agent_name": body.agent_name,
+            "agent_type": body.agent_type,
             "engine": "claude_code", **parsed}
 
 
 @router.post("/agent-prompt/verify", dependencies=[_auth])
-async def agent_prompt_verify(body: dict) -> dict:
+async def agent_prompt_verify(body: PromptVerifyRequest) -> dict:
     """Manual-trigger flow: verify a user-written prompt, then extract vars + secrets.
 
     Standards check is deterministic (our Role/Objective/Rules/Workflow/Output
@@ -919,9 +905,7 @@ async def agent_prompt_verify(body: dict) -> dict:
     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).")
+    system_prompt = body.system_prompt
 
     standards = check_system_prompt(system_prompt)
 

{devops_bot_sdk-1.4.125 → devops_bot_sdk-1.4.129}/sdk/ui/ip_allowlist.py

@@ -21,6 +21,17 @@ import os
 import socket
 
 
+def public_mode() -> bool:
+    """Opt-in PUBLIC mode (``AGENTOS_UI_PUBLIC=1``).
+
+    When set, the SDK is a public, token-authenticated server: the IP gate is
+    lifted so Swagger (``/docs``) is browsable from any IP and every ``/api/ui/*``
+    path relies SOLELY on the ``co_`` token (``require_token``) as its credential.
+    Off by default — a plain launch stays locked to loopback + allowlisted IPs.
+    """
+    return os.environ.get("AGENTOS_UI_PUBLIC", "").strip().lower() in ("1", "true", "yes", "on")
+
+
 def _loopback(ip: ipaddress._BaseAddress) -> bool:
     return ip.is_loopback
 
@@ -107,6 +118,10 @@ class IPAllowlistMiddleware(BaseHTTPMiddleware):
         return any(ip in net for net in (self._local_nets + self._configured_nets()))
 
     async def dispatch(self, request: Request, call_next):
+        # PUBLIC mode: lift the IP gate entirely — Swagger is browsable by anyone
+        # and /api/ui/* is guarded only by the co_ token (require_token). Opt-in.
+        if public_mode():
+            return await call_next(request)
         # Guard EVERY path — nothing on this server is public.
         if not self._permitted(self._client_ip(request)):
             return JSONResponse(