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

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

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

{devops_bot_sdk-1.4.151 → devops_bot_sdk-1.4.158}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.151 → devops_bot_sdk-1.4.158}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -35,6 +35,7 @@ sdk/agents/prompt_template.py
 sdk/agents/prompt_vars.py
 sdk/agents/run_log.py
 sdk/agents/secrets.py
+sdk/agents/ticket_run.py
 sdk/agents/usage.py
 sdk/agents/varstore.py
 sdk/agents/engines/__init__.py
@@ -75,19 +76,24 @@ sdk/ui/runner.py
 sdk/ui/security.py
 sdk/ui/server.py
 sdk/ui/service.py
+sdk/ui/session.py
 sdk/ui/setup_manager.py
 sdk/ui/static/agents.html
 sdk/ui/static/app.js
 sdk/ui/static/custom-agents.html
 sdk/ui/static/default-agents.html
 sdk/ui/static/index.html
+sdk/ui/static/login.html
 sdk/ui/static/runs.html
 sdk/ui/static/setup.html
 sdk/ui/static/styles.css
 sdk/ui/static/tickets.html
 tests/test_agent_chat_features.py
+tests/test_agent_prompt_async.py
 tests/test_agent_prompt_models.py
+tests/test_agent_run_ticket.py
 tests/test_agents_connectors_builder.py
 tests/test_git_action.py
 tests/test_health.py
+tests/test_otp_login.py
 tests/test_updater_extras.py

{devops_bot_sdk-1.4.151 → devops_bot_sdk-1.4.158}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.4.151
+Version: 1.4.154
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -30,7 +30,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.4.151"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.4.158"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
 __author__  = "AgentOS"   # sdk.client.SDK_VERSION and the UI server version all read this.
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.4.151 → devops_bot_sdk-1.4.158}/sdk/agentd.py

@@ -251,7 +251,9 @@ async def _wait_for_human_approval(client: BackendClient, task_id: str) -> str:
 
 async def _dispatch_agent_run(
     manifest: "AgentManifest", client: BackendClient, task: dict | None = None,
-) -> None:
+    *, auto_approve: bool = False,
+    extra_variables: dict | None = None, extra_secrets: dict | None = None,
+) -> dict:
     """Run ONE loaded ``AgentManifest`` end to end, for one trigger firing.
 
     1. Resolve skills + (optionally) an MCP config from the manifest.
@@ -262,7 +264,8 @@ async def _dispatch_agent_run(
        run, but pauses at ``awaiting_approval`` instead of executing, exactly
        like the desktop's local-execution hybrid for Jira coding tasks.
     4. Drive the GO-AHEAD / FINALIZE round-trip:
-         - ``approval.policy == "never"``: agentd sends the GO-AHEAD itself
+         - ``auto_approve`` (a human-initiated on-demand run) OR
+           ``approval.policy == "never"``: agentd sends the GO-AHEAD itself
            (``approval_reply(..., decision="APPROVED", local_execution_result=None)``)
            the moment the run reaches ``awaiting_approval``.
          - otherwise: wait for a human's WhatsApp reply to land (no early
@@ -271,7 +274,15 @@ async def _dispatch_agent_run(
        ``sdk.agents.engines.claude_code.run`` and report the result back via
        a second ``approval_reply(..., local_execution_result={...})`` call,
        which finalizes the run server-side.
+
+    ``auto_approve=True`` is used by the on-demand "run agent on a ticket" path
+    (UI / API / CLI), where a human already clicked Run — so the agent's
+    ``approval.policy`` WhatsApp gate is skipped for this single run.
+
+    Returns an outcome dict — ``{status, task_id, result, ok, error}`` — for the
+    on-demand callers; the daemon's trigger loops ignore the return value.
     """
+    outcome: dict = {"status": "", "task_id": "", "result": "", "ok": False, "error": ""}
     from sdk.agents import integrations as integrations_mod
     from sdk.agents import manifest as manifest_mod
     from sdk.agents import secrets as agent_secrets
@@ -284,7 +295,15 @@ async def _dispatch_agent_run(
     # only when the owner edits the agent. Empty for department agents, whose keys
     # come from the host .env already in os.environ.
     stored_secrets = agent_secrets.load_secrets(manifest.name)
-    secret_env = agent_secrets.resolved_env(manifest.name) if stored_secrets else None
+    # EPHEMERAL secrets: supplied for THIS run only (UI/API/CLI), merged on top of
+    # any stored keys and injected as env — NEVER written back to disk, so they
+    # vanish when the run ends. Explicit run-time values win over stored ones.
+    effective_secrets = {**(stored_secrets or {}), **(extra_secrets or {})}
+    if extra_secrets:
+        import os as _os
+        secret_env = {**_os.environ, **effective_secrets}
+    else:
+        secret_env = agent_secrets.resolved_env(manifest.name) if stored_secrets else None
 
     mcp_config: dict[str, Any] | None = None
     if manifest.integrations:
@@ -293,21 +312,23 @@ async def _dispatch_agent_run(
             manifest.integrations, available, env=secret_env,
         )
 
-    # EPHEMERAL variables: refilled FRESH from THIS ticket every run (never
-    # persisted). A scheduled/manual run with no ticket leaves them for the agent
-    # to ask about or default, exactly as before.
+    # EPHEMERAL variables: filled FRESH from the ticket (when one is attached) and/or
+    # from explicit run-time values — never persisted. Explicit ``extra_variables``
+    # win over ticket-derived ones. With neither, unresolved {{vars}} are left for
+    # the agent to ask about or default, exactly as before.
     resolved_prompt = manifest.prompt
-    if task:
-        names = extract_variables(manifest.prompt)
-        if names:
-            values = values_from_ticket(names, task)
-            resolved_prompt, missing = substitute_variables(manifest.prompt, values)
-            if values:
-                logger.info(
-                    "agentd.vars_filled agent=%s filled=%s missing=%s",
-                    manifest.name, sorted(values), sorted(missing),
-                )
-            manifest = manifest.model_copy(update={"prompt": resolved_prompt})
+    names = extract_variables(manifest.prompt)
+    if names and (task or extra_variables):
+        values = values_from_ticket(names, task) if task else {}
+        if extra_variables:
+            values = {**values, **{k: str(v) for k, v in extra_variables.items() if str(v).strip()}}
+        resolved_prompt, missing = substitute_variables(manifest.prompt, values)
+        if values:
+            logger.info(
+                "agentd.vars_filled agent=%s filled=%s missing=%s",
+                manifest.name, sorted(values), sorted(missing),
+            )
+        manifest = manifest.model_copy(update={"prompt": resolved_prompt})
 
     if manifest.engine != "claude_code":
         # Only claude_code is wired end-to-end today (sdk/agents/engines/{mcp,
@@ -317,7 +338,8 @@ async def _dispatch_agent_run(
         logger.warning(
             "agentd.engine_not_wired engine=%s agent=%s", manifest.engine, manifest.name,
         )
-        return
+        outcome["error"] = f"engine '{manifest.engine}' is not wired (only claude_code)."
+        return outcome
 
     prompt_text = manifest.prompt
     if skill_text:
@@ -341,8 +363,9 @@ async def _dispatch_agent_run(
             return
         handled.add(task_id)
 
-        if policy == "never":
-            # No human in the loop for this agent — agentd IS the approver.
+        if auto_approve or policy == "never":
+            # No human in the loop for this run — agentd IS the approver
+            # (agent policy 'never', or a human already clicked Run on-demand).
             try:
                 await client.approval_reply(
                     task_id, decision="APPROVED", local_execution_result=None,
@@ -380,15 +403,21 @@ async def _dispatch_agent_run(
                 run_log.log_event(_log_path, ev)
 
             local_result = await claude_code_engine.run(
-                manifest, skill_text, mcp_config, extra_env=stored_secrets or None,
+                manifest, skill_text, mcp_config, extra_env=effective_secrets or None,
                 on_event=_tee,
             )
             run_log.finish_run(_log_path, local_result)
+            outcome.update({
+                "task_id": task_id,
+                "result": local_result.get("result", ""),
+                "ok": bool(local_result.get("ok", True)),
+            })
         except Exception as exc:  # noqa: BLE001
             logger.warning(
                 "agentd.local_run_failed agent=%s task=%s err=%s",
                 manifest.name, task_id, exc,
             )
+            outcome["error"] = str(exc)
             return
 
         # FINALIZE — same field names sdk.local_exec.run_claude_local's result
@@ -417,11 +446,14 @@ async def _dispatch_agent_run(
         result = await client.orchestrate(req, on_status_update=_on_status_update)
     except Exception as exc:  # noqa: BLE001
         logger.warning("agentd.orchestrate_failed agent=%s err=%s", manifest.name, exc)
-        return
+        outcome["error"] = str(exc)
+        return outcome
 
     logger.info(
         "agentd.run_complete agent=%s status=%s", manifest.name, getattr(result, "status", ""),
     )
+    outcome["status"] = getattr(result, "status", "") or ""
+    return outcome
 
 
 # ── The daemon ───────────────────────────────────────────────────────────────

devops_bot_sdk-1.4.158/sdk/agents/ticket_run.py

@@ -0,0 +1,97 @@
+"""On-demand "run an agent ON a Jira ticket" — the manual counterpart to the
+``agentd`` ``ticket_label`` trigger.
+
+The daemon fires an agent when a To-Do ticket carries its label; this module
+lets a human pick an agent AND a ticket and run it now (from the UI, the API, or
+the CLI). It reuses the exact same engine — ``agentd._dispatch_agent_run`` — so
+the ticket's fields fill the agent's ``{{variables}}`` and the work is planned,
+gated, executed locally, and reported back to the platform against that ticket.
+
+Because a human initiated the run, ``auto_approve=True`` is passed: the GO-AHEAD
+is sent immediately, skipping the agent's ``approval.policy`` WhatsApp gate for
+this single run.
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from sdk.agents.manifest import AgentManifest
+    from sdk.client import BackendClient
+
+
+async def resolve_manifest(
+    client: "BackendClient", name: str, scope: str = "custom", department_id: str = "",
+) -> "AgentManifest | None":
+    """Find the agent manifest to run, by ``scope``.
+
+    * ``custom`` (default) — a personal agent from the local manifests
+      (``~/.agentos/agents``).
+    * ``department`` — an ACTIVE department default pulled from the backend
+      (``list_department_agents``), materialized read-only (never written back),
+      exactly as ``agentd._load_department_agents`` does.
+
+    Returns None when no matching agent is found.
+    """
+    from sdk.agents.manifest import AgentManifest, load_agents
+
+    name = (name or "").strip()
+    if scope == "department":
+        try:
+            rows = await client.list_department_agents()
+        except Exception:  # noqa: BLE001 — treat a backend hiccup as "not found"
+            return None
+        for row in rows:
+            if row.get("name") == name and row.get("status") == "active":
+                try:
+                    return AgentManifest(**row["manifest"])
+                except Exception:  # noqa: BLE001 — invalid manifest → not runnable
+                    return None
+        return None
+
+    for m in load_agents():
+        if m.name == name:
+            return m
+    return None
+
+
+async def run_on_ticket(
+    client: "BackendClient", name: str, ticket_key: str = "",
+    scope: str = "custom", department_id: str = "",
+    variables: dict | None = None, secrets: dict | None = None,
+) -> dict:
+    """Run agent ``name`` (``scope``) now, OPTIONALLY against a Jira ticket.
+
+    * ``ticket_key`` — optional. When given, the ticket record is fetched (any
+      board status — a targeted run may re-run a Done ticket) and its fields fill
+      the agent's ``{{variables}}``. When omitted, the agent runs without a ticket.
+    * ``variables`` — optional EPHEMERAL ``{{var}}`` values for this run; they win
+      over ticket-derived values and are never persisted.
+    * ``secrets`` — optional EPHEMERAL env secrets for this run only; injected for
+      the engine invocation and never written to the agent's stored keys.
+
+    Resolves the manifest and dispatches through the shared pipeline with
+    ``auto_approve=True``. Returns the dispatch outcome dict
+    (``{status, task_id, result, ok, error}``).
+
+    Raises ``ValueError`` when the agent — or an explicitly-named ticket — cannot
+    be found, so the caller reports a clear message.
+    """
+    from sdk.agentd import _dispatch_agent_run
+
+    key = (ticket_key or "").strip()
+    task: dict | None = None
+    if key:
+        records = await client.list_tasks_by_keys([key])
+        if not records:
+            raise ValueError(f"Jira ticket '{key}' was not found.")
+        task = records[0]
+
+    manifest = await resolve_manifest(client, name, scope=scope, department_id=department_id)
+    if manifest is None:
+        raise ValueError(f"Agent '{name}' was not found (scope={scope}).")
+
+    return await _dispatch_agent_run(
+        manifest, client, task, auto_approve=True,
+        extra_variables=variables or None, extra_secrets=secrets or None,
+    )

{devops_bot_sdk-1.4.151 → devops_bot_sdk-1.4.158}/sdk/cli.py

@@ -131,6 +131,9 @@ def _agent_command(args: list[str]) -> None:
     if verb == "run" and rest:
         _agent_run(rest[0])
         return
+    if verb == "run-ticket" and rest:
+        _agent_run_ticket(rest[0], rest[1:])
+        return
     if verb == "chat" and len(rest) >= 2:
         _agent_chat(rest[0], " ".join(rest[1:]))
         return
@@ -156,9 +159,10 @@ def _agent_command(args: list[str]) -> None:
         _agent_rm_key(rest[0], rest[1:])
         return
 
-    print("usage: agentos agent <new|add PATH|list|run NAME|chat NAME MESSAGE|template [NAME]|"
-          "logs NAME|enable NAME|disable NAME|rm NAME|set-key NAME KEY[=VALUE]…|keys NAME|"
-          "rm-key NAME KEY…>")
+    print("usage: agentos agent <new|add PATH|list|run NAME|run-ticket NAME [--ticket KEY] "
+          "[--var k=v]… [--secret K=V]… [--scope department --department-id UUID]|chat NAME MESSAGE|"
+          "template [NAME]|logs NAME|enable NAME|disable NAME|rm NAME|set-key NAME KEY[=VALUE]…|"
+          "keys NAME|rm-key NAME KEY…>")
     sys.exit(1)
 
 
@@ -220,6 +224,61 @@ def _agent_list() -> None:
         )
 
 
+def _agent_run_ticket(name: str, flags: list[str]) -> None:
+    """`agentos agent run-ticket NAME [--ticket KEY] [--var k=v]… [--secret K=V]…
+    [--scope department] [--department-id UUID]`.
+
+    Runs the agent through the platform pipeline. A ``--ticket`` is OPTIONAL (its
+    fields fill the agent's ``{{variables}}``); ``--var``/``--secret`` are
+    EPHEMERAL (this run only, never stored). Auto-approved.
+    """
+    from sdk.agents import ticket_run
+    from sdk.client import BackendClient
+
+    scope, department_id, ticket_key = "custom", "", ""
+    variables: dict = {}
+    secrets: dict = {}
+    i = 0
+    while i < len(flags):
+        f = flags[i]
+        if f == "--ticket" and i + 1 < len(flags):
+            ticket_key = flags[i + 1]; i += 2
+        elif f == "--scope" and i + 1 < len(flags):
+            scope = flags[i + 1]; i += 2
+        elif f == "--department-id" and i + 1 < len(flags):
+            department_id = flags[i + 1]; i += 2
+        elif f == "--var" and i + 1 < len(flags):
+            k, _, v = flags[i + 1].partition("=")
+            if k.strip():
+                variables[k.strip()] = v
+            i += 2
+        elif f == "--secret" and i + 1 < len(flags):
+            k, _, v = flags[i + 1].partition("=")
+            if k.strip():
+                secrets[k.strip()] = v
+            i += 2
+        else:
+            i += 1
+
+    client = BackendClient.from_config()
+    try:
+        outcome = asyncio.run(ticket_run.run_on_ticket(
+            client, name, ticket_key, scope=scope, department_id=department_id,
+            variables=variables or None, secrets=secrets or None,
+        ))
+    except ValueError as exc:
+        print(f"error: {exc}")
+        sys.exit(1)
+
+    if outcome.get("error"):
+        print(f"error: {outcome['error']}")
+        sys.exit(1)
+    target = f" on {ticket_key}" if ticket_key else ""
+    print(f"ran '{name}'{target} — status={outcome.get('status') or 'done'}")
+    if outcome.get("result"):
+        print(f"\n{outcome['result']}")
+
+
 def _agent_run(name: str) -> None:
     from sdk.agents.manifest import AgentManifest, load_agents
     from sdk.client import BackendClient

{devops_bot_sdk-1.4.151 → devops_bot_sdk-1.4.158}/sdk/config.py

@@ -149,6 +149,13 @@ def _dotenv_value(key: str) -> str:
     return ""
 
 
+# Built-in permanent allowlist — the central AI backend's IP(s). Baked in so the
+# backend can reach EVERY VPS's /api/ui/* out of the box (no per-VPS .env needed);
+# always allowed, treated as permanent (not removable via the API). Extend/override
+# with AGENTOS_UI_ALLOWED_IPS in .env or the process env.
+_DEFAULT_ALLOWED_IPS: list[str] = ["20.12.201.148"]
+
+
 def _parse_ip_list(raw: str) -> list[str]:
     """Split an IP allowlist string, tolerant of JSON-ish list syntax.
 
@@ -181,6 +188,7 @@ def get_allowed_ips() -> list[str]:
     change. CIDR/prefix entries are supported by the middleware.
     """
     sources = [
+        ",".join(_DEFAULT_ALLOWED_IPS),                 # built-in backend IP(s) — always allowed
         _dotenv_value("AGENTOS_UI_ALLOWED_IPS"),
         os.environ.get("AGENTOS_UI_ALLOWED_IPS", ""),
         _load_raw().get("allowed_ips", ""),
@@ -205,7 +213,8 @@ def permanent_allowed_ips() -> list[str]:
     through the API — change them by editing ``.env`` and restarting.
     """
     out: list[str] = []
-    for src in (_dotenv_value("AGENTOS_UI_ALLOWED_IPS"),
+    for src in (",".join(_DEFAULT_ALLOWED_IPS),          # built-in backend IP(s) — always permanent
+                _dotenv_value("AGENTOS_UI_ALLOWED_IPS"),
                 os.environ.get("AGENTOS_UI_ALLOWED_IPS", "")):
         for ip in _parse_ip_list(src):
             if ip not in out:
@@ -278,6 +287,25 @@ def get_branch_name_template() -> str | None:
     return val.strip() if val and val.strip() else None
 
 
+def get_session_secret() -> str:
+    """Return the per-SDK secret used to sign OTP login sessions.
+
+    Generated once (32 random bytes, hex) on first use and persisted to
+    config.toml ``session_secret`` — so sessions survive a restart but are unique
+    per box (a session minted on one VPS is meaningless on another). The merge
+    preserves ``token_enc`` / ``base_url`` / ``allowed_ips``. File mode stays 0600.
+    """
+    import secrets as _secrets
+
+    raw = _load_raw()
+    secret = (raw.get("session_secret") or "").strip()
+    if not secret:
+        secret = _secrets.token_hex(32)
+        raw["session_secret"] = secret
+        _save_raw(raw)
+    return secret
+
+
 def get_token() -> str:
     """Return the stored apiTokenHash. Raises TokenNotConfigured if missing."""
     cfg = load()