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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.126
+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.126 → 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.126
+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.126 → 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.126 → 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.126
+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.126"   # 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.126 → 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.126 → devops_bot_sdk-1.4.129}/sdk/ui/api.py

@@ -12,6 +12,24 @@ 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")
 
@@ -82,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.
@@ -109,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])
@@ -137,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):
@@ -184,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)
 
 
@@ -426,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
@@ -435,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])
@@ -516,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
@@ -526,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:
@@ -552,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).
@@ -593,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
@@ -603,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
@@ -637,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),
@@ -649,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
@@ -688,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.
@@ -697,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
@@ -748,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
@@ -756,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
@@ -778,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
@@ -787,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
@@ -809,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``,
@@ -820,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
@@ -874,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``.
@@ -882,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"]:
@@ -898,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``,
@@ -906,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
@@ -935,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.129/sdk/ui/models.py

@@ -0,0 +1,366 @@
+"""Pydantic request models for the ``/api/ui/*`` control-panel API.
+
+One model per endpoint body. These replace the previous bare ``body: dict``
+signatures so inputs are validated (types, required fields, formats) before a
+handler runs, and Swagger renders a real schema/example instead of a free-form
+object. A validation failure surfaces as HTTP 422 (FastAPI's standard) with a
+field-level message.
+
+Behaviour is preserved from the old hand-rolled checks: strings are stripped,
+optional fields keep their previous defaults, and the polymorphic / alias inputs
+(``keys`` as string-or-list, ``scope`` falling back to ``source``) are normalised
+here via validators so handlers stay thin.
+"""
+from __future__ import annotations
+
+import ipaddress
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+
+def _normalise_keys(v: object) -> list[str]:
+    """A whitespace-separated string OR a list → a clean, non-empty-item list."""
+    if v is None:
+        return []
+    if isinstance(v, str):
+        v = v.split()
+    if not isinstance(v, (list, tuple)):
+        raise ValueError("keys must be a string or a list.")
+    return [str(k).strip() for k in v if str(k).strip()]
+
+
+# ── IP allowlist ────────────────────────────────────────────────────────────
+
+class AllowlistEntry(BaseModel):
+    """Body for ``POST /api/ui/allowlist`` — one IP or CIDR to whitelist."""
+
+    ip: str = Field(
+        ...,
+        description="IPv4/IPv6 address or CIDR block to whitelist, "
+                    "e.g. '203.0.113.4' or '10.0.0.0/8'.",
+        examples=["203.0.113.4"],
+    )
+
+    @field_validator("ip")
+    @classmethod
+    def _valid_ip_or_cidr(cls, value: str) -> str:
+        value = (value or "").strip()
+        if not value:
+            raise ValueError("ip is required.")
+        try:
+            ipaddress.ip_network(value, strict=False)
+        except ValueError:
+            raise ValueError(f"invalid IP or CIDR: {value!r}")
+        return value
+
+
+# ── Setup / configuration ────────────────────────────────────────────────────
+
+class ConfigureRequest(BaseModel):
+    """Body for ``POST /api/ui/configure`` — save the DevOpsBot API token."""
+
+    token: str = Field(..., description="DevOpsBot API token; must start with 'co_'.",
+                        examples=["co_<userUuid>_<secret>"])
+
+    @field_validator("token")
+    @classmethod
+    def _co_token(cls, value: str) -> str:
+        value = (value or "").strip()
+        if not value.startswith("co_"):
+            raise ValueError("Token must start with 'co_'.")
+        return value
+
+
+class SetupRequest(BaseModel):
+    """Body for ``POST /api/ui/setup`` (optional)."""
+
+    upgrade: bool = True
+
+
+# ── Execution (agentos-auto subcommands) ──────────────────────────────────────
+
+class WorkspaceRequest(BaseModel):
+    """Body for ``POST /api/ui/run`` and ``/resume`` (both optional)."""
+
+    workspace_root: str | None = None
+
+    @field_validator("workspace_root")
+    @classmethod
+    def _strip(cls, value: str | None) -> str | None:
+        if value is None:
+            return None
+        value = str(value).strip()
+        return value or None
+
+
+class TicketRequest(BaseModel):
+    """Body for ``POST /api/ui/ticket`` — one or more Jira ticket keys."""
+
+    keys: list[str] = Field(default_factory=list, examples=[["PROJ-123", "PROJ-124"]])
+    workspace_root: str | None = None
+
+    @field_validator("keys", mode="before")
+    @classmethod
+    def _norm(cls, v: object) -> list[str]:
+        return _normalise_keys(v)
+
+    @field_validator("keys")
+    @classmethod
+    def _at_least_one(cls, v: list[str]) -> list[str]:
+        if not v:
+            raise ValueError("Provide at least one ticket key.")
+        return v
+
+    @field_validator("workspace_root")
+    @classmethod
+    def _strip(cls, value: str | None) -> str | None:
+        if value is None:
+            return None
+        value = str(value).strip()
+        return value or None
+
+
+class StoryRequest(BaseModel):
+    """Body for ``POST /api/ui/story`` (optional) — zero or more story keys."""
+
+    keys: list[str] = Field(default_factory=list)
+
+    @field_validator("keys", mode="before")
+    @classmethod
+    def _norm(cls, v: object) -> list[str]:
+        return _normalise_keys(v)
+
+
+# ── Custom agents: keys / update / chat / run ────────────────────────────────
+
+class AgentKeysSet(BaseModel):
+    """Body for ``POST /api/ui/agents/keys`` — persist a custom agent's API keys."""
+
+    name: str = Field(..., description="Custom agent name.")
+    # Values are coerced to str by the handler (matching prior behaviour), so accept
+    # any JSON scalar here rather than rejecting e.g. a numeric value with 422.
+    keys: dict[str, object] = Field(..., description="{ENV_VAR: value} — merged into stored keys.")
+
+    @field_validator("name")
+    @classmethod
+    def _name(cls, value: str) -> str:
+        value = (value or "").strip()
+        if not value:
+            raise ValueError("name is required.")
+        return value
+
+    @field_validator("keys")
+    @classmethod
+    def _nonempty(cls, value: dict[str, object]) -> dict[str, object]:
+        if not value:
+            raise ValueError("keys must be a non-empty object.")
+        return value
+
+
+class UpdateAgentRequest(BaseModel):
+    """Body for ``PATCH /api/ui/agents`` — edit a local custom agent.
+
+    PATCH semantics: only fields the caller actually sends are applied. The
+    handler reads ``model_fields_set`` (via ``exclude_unset``) to tell "not sent"
+    apart from "sent as empty". ``name`` is the immutable identity.
+    """
+
+    name: str = Field(..., description="Agent name (identity — immutable).")
+    description: str | None = None
+    prompt: str | None = None
+    allowed_tools: list[str] | None = None
+    status: str | None = None
+
+    @field_validator("name")
+    @classmethod
+    def _name(cls, value: str) -> str:
+        value = (value or "").strip()
+        if not value:
+            raise ValueError("name is required.")
+        return value
+
+
+class AgentChatRequest(BaseModel):
+    """Body for ``POST /api/ui/agents/chat``."""
+
+    name: str = Field(..., description="Agent name.")
+    message: str = Field(..., description="User message.")
+    variables: dict = Field(default_factory=dict)
+    history: list = Field(default_factory=list)
+    department_id: str = ""
+
+    @field_validator("name", "message")
+    @classmethod
+    def _required(cls, value: str) -> str:
+        value = (value or "").strip()
+        if not value:
+            raise ValueError("name and message are required.")
+        return value
+
+    @field_validator("department_id")
+    @classmethod
+    def _strip(cls, value: str) -> str:
+        return (value or "").strip()
+
+
+class AgentRunRequest(BaseModel):
+    """Body for ``POST /api/ui/agents/run``.
+
+    ``scope`` accepts a legacy ``source`` alias and defaults to ``"custom"``.
+    """
+
+    name: str = Field(..., description="Agent name.")
+    variables: dict = Field(default_factory=dict)
+    department_id: str = ""
+    scope: str = "custom"
+
+    @model_validator(mode="before")
+    @classmethod
+    def _scope_from_source(cls, data: object) -> object:
+        if isinstance(data, dict):
+            scope = data.get("scope") or data.get("source") or "custom"
+            data = {**data, "scope": scope}
+        return data
+
+    @field_validator("name")
+    @classmethod
+    def _name(cls, value: str) -> str:
+        value = (value or "").strip()
+        if not value:
+            raise ValueError("name is required.")
+        return value
+
+    @field_validator("department_id")
+    @classmethod
+    def _strip_dept(cls, value: str) -> str:
+        return (value or "").strip()
+
+    @field_validator("scope")
+    @classmethod
+    def _scope(cls, value: str) -> str:
+        return (value or "").strip() or "custom"
+
+
+# ── System assistant ─────────────────────────────────────────────────────────
+
+class SystemChatRequest(BaseModel):
+    """Body for ``POST /api/ui/system/chat``."""
+
+    message: str = Field(..., description="Question for the System Assistant.")
+    history: list = Field(default_factory=list)
+
+    @field_validator("message")
+    @classmethod
+    def _required(cls, value: str) -> str:
+        value = (value or "").strip()
+        if not value:
+            raise ValueError("message is required.")
+        return value
+
+
+# ── Prompt Studio ─────────────────────────────────────────────────────────────
+
+# The agent-prompt/* models below intentionally mirror the AI backend's request
+# schemas field-for-field (routes/agent_prompt.py: Generate/Regenerate/Verify),
+# so one JSON body works against both /api/v1/agent-prompt/* (backend) and
+# /api/ui/agent-prompt/* (this SDK). ``engine`` is part of that shared contract;
+# the SDK always runs ``claude_code`` locally, so it accepts the field for parity
+# and ignores non-local values rather than 400ing.
+_ENGINE_DESC = "'claude_code' (local SDK) or 'server' (backend LLM)."
+
+
+class SystemPromptRequest(BaseModel):
+    """Body for the SDK-only Prompt Studio helpers (``/prompt/analyze``,
+    ``/prompt/comments``) — no backend equivalent, so no ``engine`` field."""
+
+    system_prompt: str = Field(..., description="The system prompt to analyse.")
+
+    @field_validator("system_prompt")
+    @classmethod
+    def _min_len(cls, value: str) -> str:
+        value = (value or "").strip()
+        if len(value) < 10:
+            raise ValueError("Write a system prompt first (a bit longer).")
+        return value
+
+
+class PromptVerifyRequest(BaseModel):
+    """Body for ``POST /api/ui/agent-prompt/verify`` — mirrors the backend's
+    ``VerifyPromptRequest`` (``system_prompt`` + ``engine``)."""
+
+    system_prompt: str = Field(..., description="The user-written prompt to verify.")
+    engine: str = Field("claude_code", description=_ENGINE_DESC)
+
+    @field_validator("system_prompt")
+    @classmethod
+    def _min_len(cls, value: str) -> str:
+        value = (value or "").strip()
+        if len(value) < 10:
+            raise ValueError("Write a system prompt first (a bit longer).")
+        return value
+
+
+class PromptRunRequest(BaseModel):
+    """Body for ``POST /api/ui/prompt/run``."""
+
+    system_prompt: str = Field(..., description="System prompt to run.")
+    inputs: dict = Field(default_factory=dict)
+    output_format: str = ""
+    tools: list[str] = Field(default_factory=list)
+
+    @field_validator("system_prompt")
+    @classmethod
+    def _required(cls, value: str) -> str:
+        value = (value or "").strip()
+        if not value:
+            raise ValueError("system_prompt is required.")
+        return value
+
+    @field_validator("output_format")
+    @classmethod
+    def _strip(cls, value: str) -> str:
+        return (value or "").strip()
+
+
+class PromptRegenerateRequest(BaseModel):
+    """Body for ``POST /api/ui/agent-prompt/regenerate`` — mirrors the backend's
+    ``RegeneratePromptRequest``."""
+
+    system_prompt: str = Field(..., description="The existing prompt to improve.")
+    feedback: str = Field("", description="Optional guidance on what to change.")
+    agent_name: str = Field("", description="Optional context: the agent's name.")
+    agent_type: str = Field("", description="Optional context: the agent's type.")
+    job: str = Field("", description="Optional context: the agent's main job.")
+    engine: str = Field("claude_code", description=_ENGINE_DESC)
+
+    @field_validator("system_prompt")
+    @classmethod
+    def _required(cls, value: str) -> str:
+        value = (value or "").strip()
+        if not value:
+            raise ValueError("system_prompt is required.")
+        return value
+
+    @field_validator("agent_name", "agent_type")
+    @classmethod
+    def _strip(cls, value: str) -> str:
+        return (value or "").strip()
+
+
+class AgentPromptGenerateRequest(BaseModel):
+    """Body for ``POST /api/ui/agent-prompt/generate`` — mirrors the backend's
+    ``GeneratePromptRequest``."""
+
+    agent_name: str = Field(..., description="The agent's name, e.g. 'Release Notes Writer'.")
+    agent_type: str = Field(..., description="The agent's type/category, e.g. 'documentation'.")
+    job: str = Field(..., description="The agent's main job, in plain language.")
+    context: str = Field("", description="Optional extra context to steer the prompt.")
+    engine: str = Field("claude_code", description=_ENGINE_DESC)
+
+    @field_validator("agent_name", "agent_type", "job")
+    @classmethod
+    def _required(cls, value: str) -> str:
+        value = (value or "").strip()
+        if not value:
+            raise ValueError("agent_name, agent_type, and job are required.")
+        return value

{devops_bot_sdk-1.4.126 → devops_bot_sdk-1.4.129}/sdk/ui/service.py

@@ -222,3 +222,38 @@ def status() -> str:
     if _systemd_available():
         return _status_systemd()
     return "no supported service manager found."
+
+
+def restart() -> tuple[bool, str]:
+    """Restart the installed agentos-ui service so it re-imports the on-disk code.
+
+    A running server holds the routes it imported at boot, so a package upgrade
+    (``agentos-auto update``) doesn't expose newly-added APIs until the process
+    restarts. This performs that restart via whatever manager installed it.
+    Best-effort: returns ``(False, msg)`` when no managed service is found, so a
+    manually-launched panel is left untouched (the operator restarts it himself).
+    """
+    if IS_WINDOWS:
+        _run(["schtasks", "/End", "/TN", WIN_TASK])
+        rc, out = _run(["schtasks", "/Run", "/TN", WIN_TASK])
+        return (rc == 0), (f"restarted scheduled task '{WIN_TASK}'." if rc == 0 else out)
+    if IS_MAC:
+        path = _mac_plist_path()
+        if not path.exists():
+            return False, "no launchd agent installed — restart the panel manually."
+        _run(["launchctl", "unload", str(path)])
+        rc, out = _run(["launchctl", "load", "-w", str(path)])
+        return (rc == 0), (f"restarted launchd agent '{_MAC_LABEL}'." if rc == 0 else out)
+    if _systemd_available():
+        is_root = hasattr(os, "geteuid") and os.geteuid() == 0
+        sysctl = ["systemctl"] if is_root else ["systemctl", "--user"]
+        # Only restart a unit that actually exists, so we don't spam errors on a
+        # box where the panel runs under nohup/tmux instead of systemd.
+        rc, _ = _run([*sysctl, "list-unit-files", f"{SERVICE_NAME}.service"])
+        _, active = _run([*sysctl, "is-active", SERVICE_NAME])
+        if rc != 0 and active.strip() not in ("active", "activating"):
+            return False, f"no systemd unit '{SERVICE_NAME}' — restart the panel manually."
+        rc, out = _run([*sysctl, "restart", SERVICE_NAME])
+        return (rc == 0), (f"restarted systemd service '{SERVICE_NAME}'." if rc == 0
+                           else out or f"systemctl restart {SERVICE_NAME} failed")
+    return False, "no supported service manager found — restart the panel manually (`agentos-ui`)."