devops-bot-sdk 1.2.0__tar.gz → 1.4.0__tar.gz

{devops_bot_sdk-1.2.0 → devops_bot_sdk-1.4.0}/PKG-INFO

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

{devops_bot_sdk-1.2.0 → devops_bot_sdk-1.4.0}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.2.0 → devops_bot_sdk-1.4.0}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -10,9 +10,11 @@ sdk/__init__.py
 sdk/client.py
 sdk/config.py
 sdk/exceptions.py
+sdk/local_exec.py
 sdk/py.typed
 sdk/sse.py
 sdk/test.py
+sdk/test_pipeline.py
 sdk/collectors/__init__.py
 sdk/collectors/files.py
 sdk/collectors/process.py

{devops_bot_sdk-1.2.0 → devops_bot_sdk-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devops-bot-sdk"
-version = "1.2.0"
+version = "1.4.0"
 description = "DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app"
 readme = "README.md"
 license = "LicenseRef-Proprietary"

{devops_bot_sdk-1.2.0 → devops_bot_sdk-1.4.0}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.1.0
+Version: 1.4.0
 
 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.1.0"
+__version__ = "1.4.0"
 __author__  = "AgentOS"
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.2.0 → devops_bot_sdk-1.4.0}/sdk/client.py

@@ -29,15 +29,18 @@ from sdk.models.requests import (
 from sdk.models.responses import (
     BootstrapData, ChatHistory, OAuthStarted, PipelineResult, PipelineStatus,
     ThreadSummary, WebhookAck,
+    OrchestrateAutoStatusResponse, OrchestrateAutoStopResponse, OrchestrateAutoResumeResponse,
+    OrchestrateAutoStopAllResponse, OrchestrateAutoResumeAllResponse,
 )
 from sdk.sse import _check_status, stream_with_reconnect
 
 logger = logging.getLogger(__name__)
 
-SDK_VERSION    = "1.1.0"
+SDK_VERSION    = "1.4.0"
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
-_ORCHESTRATE_TIMEOUT = 900.0  # 15 min — a real Claude Code dev run can take minutes
+_ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time
+_AUTO_ORCHESTRATE_TIMEOUT = 2700.0  # 45 min — same budget for multi-task auto runs
 
 
 class BackendClient:
@@ -248,38 +251,273 @@ class BackendClient:
         _check_status(resp.status_code, self._base_url)
         return resp.json()
 
-    async def orchestrate(self, req: OrchestrateRequest) -> PipelineResult:
-        """POST /api/v1/orchestrate — run the full System-B pipeline synchronously.
-
-        This is the path that honours `dev_engine` / `model` / `apply_diffs`
-        and drives the ML_TASK_FLOW lifecycle (`jira_task_id` → In Progress /
-        approval gate / Done). Unlike `orchestrator_run` (async 202 + poll on
-        /orchestrator/run), this blocks until the run finishes — a real Claude
-        Code dev run can take minutes, hence the long timeout.
-
-        `user_id` is auto-filled from the token when omitted.
+    async def orchestrate(
+        self,
+        req: OrchestrateRequest,
+        on_status_update=None,
+    ) -> PipelineResult:
+        """POST /api/v1/orchestrate (background) → poll status → PipelineResult.
+
+        Runs the full System-B pipeline (engine selection + ML_TASK_FLOW lifecycle).
+        A real dev run takes minutes, so this uses the backend's **background**
+        mode: it POSTs `background:true` (202 + session_id), then polls
+        /orchestrate/status/{session_id} until the run is terminal — avoiding
+        HTTP timeouts on the long call.
+
+        Minimal request: OrchestrateRequest(jira_task_id="..."). The backend
+        hydrates user_id from the co_ token, role_slug from the profile,
+        user_input from the task's summary + description, and project_path via
+        its AI workspace resolver — so none of them need to be sent.
+
+        `on_status_update`: optional async callable(status: str, state: dict).
+        Called whenever the polled status changes — useful for emitting
+        intermediate `awaiting_approval` events to the IPC layer without
+        stopping the poll loop.
         """
         body = req.model_dump(exclude_none=True)
+        body["background"] = True
+        # Best-effort local fill — the backend derives user_id from the co_
+        # token anyway, so a token in an unexpected shape is not an error.
         if not body.get("user_id"):
             derived = self._user_id_from_token()
-            if not derived:
-                raise BackendAuthFailed(self._url("/api/v1/orchestrate"))
-            body["user_id"] = derived
+            if derived:
+                body["user_id"] = derived
 
+        # 1. Kick off the background run (202).
         try:
-            async with httpx.AsyncClient(timeout=_ORCHESTRATE_TIMEOUT) as client:
+            async with httpx.AsyncClient(timeout=30.0) as client:
                 resp = await client.post(
                     self._url("/api/v1/orchestrate"),
                     json=body,
                     headers=self._headers,
                 )
             _check_status(resp.status_code, self._url("/api/v1/orchestrate"))
-            return PipelineResult(**resp.json())
+            session_id = resp.json()["session_id"]
+        except (BackendAuthFailed, BackendVersionTooOld):
+            raise
+        except Exception as exc:
+            raise BackendUnreachable(self._base_url, str(exc)) from exc
+
+        # 2. Poll until terminal (or the overall deadline).
+        # "awaiting_approval" is NOT terminal — we keep polling so the client
+        # receives the final result after the approver replies on WhatsApp.
+        terminal = {"completed", "failed"}
+        last_reported_status: str | None = None
+        last_reported_step: str | None = None
+        deadline = asyncio.get_event_loop().time() + _ORCHESTRATE_TIMEOUT
+        while asyncio.get_event_loop().time() < deadline:
+            await asyncio.sleep(_POLL_INTERVAL)
+            try:
+                state = await self._orchestrate_status(session_id)
+            except (BackendAuthFailed, BackendVersionTooOld):
+                raise
+            except Exception:
+                continue  # transient — keep polling
+
+            current_status = str(state.get("status", ""))
+            current_step = state.get("current_step")
+
+            # Notify caller on any status or step change — lets the IPC layer
+            # forward real-time progress events to the desktop without stopping
+            # the poll loop.
+            if on_status_update and (
+                current_status != last_reported_status
+                or current_step != last_reported_step
+            ):
+                last_reported_status = current_status
+                last_reported_step = current_step
+                try:
+                    await on_status_update(current_status, state)
+                except Exception:
+                    pass
+
+            if current_status in terminal:
+                return PipelineResult(**state)
+        return PipelineResult(session_id=session_id, status="failed",
+                              error="Pipeline poll timed out.")
+
+    async def _orchestrate_status(self, session_id: str) -> dict:
+        """GET /api/v1/orchestrate/status/{session_id}"""
+        async with httpx.AsyncClient(timeout=15.0) as client:
+            resp = await client.get(
+                self._url(f"/api/v1/orchestrate/status/{session_id}"),
+                headers=self._headers,
+            )
+        _check_status(resp.status_code, self._base_url)
+        return resp.json()
+
+    # ── orchestrate-auto ──────────────────────────────────────────────────
+
+    async def orchestrate_auto(
+        self,
+        on_status_update=None,
+    ) -> OrchestrateAutoStatusResponse:
+        """POST /api/v1/orchestrate-auto → poll status → OrchestrateAutoStatusResponse.
+
+        Auto-discovers all "To Do" Jira tasks assigned to the current user and
+        runs the full System-B pipeline for each sequentially in the background.
+        Returns 202 immediately; this method polls GET /api/v1/orchestrate-auto/status
+        until the overall run reaches a terminal state (completed / failed / no_tasks).
+
+        on_status_update: optional async callable(auto_status: str, state: dict).
+        Called whenever auto_status or any per-task status changes.
+        """
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.post(
+                    self._url("/api/v1/orchestrate-auto"),
+                    headers=self._headers,
+                )
+            _check_status(resp.status_code, self._url("/api/v1/orchestrate-auto"))
+        except (BackendAuthFailed, BackendVersionTooOld):
+            raise
+        except Exception as exc:
+            raise BackendUnreachable(self._base_url, str(exc)) from exc
+
+        return await self._poll_auto_terminal(on_status_update)
+
+    async def _poll_auto_terminal(
+        self,
+        on_status_update=None,
+    ) -> OrchestrateAutoStatusResponse:
+        """Poll GET /orchestrate-auto/status until the run reaches a terminal state.
+
+        `paused` counts as terminal: a whole-run stop (this client's or another's)
+        ends the wait — the run continues only after an explicit resume.
+        """
+        terminal = {"completed", "failed", "no_tasks", "paused"}
+        last_auto_status: str | None = None
+        last_task_statuses: dict[str, str] = {}
+        deadline = asyncio.get_event_loop().time() + _AUTO_ORCHESTRATE_TIMEOUT
+
+        while asyncio.get_event_loop().time() < deadline:
+            await asyncio.sleep(_POLL_INTERVAL)
+            try:
+                state = await self._orchestrate_auto_status()
+            except (BackendAuthFailed, BackendVersionTooOld):
+                raise
+            except Exception:
+                continue
+
+            auto_status = str(state.get("auto_status", ""))
+            tasks = state.get("tasks", [])
+            current_task_statuses = {
+                t.get("session_id", ""): t.get("status", "") for t in tasks
+            }
+
+            if on_status_update and (
+                auto_status != last_auto_status
+                or current_task_statuses != last_task_statuses
+            ):
+                last_auto_status = auto_status
+                last_task_statuses = current_task_statuses
+                try:
+                    await on_status_update(auto_status, state)
+                except Exception:
+                    pass
+
+            if auto_status in terminal:
+                return OrchestrateAutoStatusResponse(**state)
+
+        return OrchestrateAutoStatusResponse(auto_status="failed")
+
+    async def orchestrate_auto_stop(self, session_id: str) -> OrchestrateAutoStopResponse:
+        """POST /api/v1/orchestrate-auto/stop/{session_id} — pause a running pipeline.
+
+        Cancels the asyncio background task on the server and saves a resume
+        snapshot to Redis. The session can be continued via orchestrate_auto_resume().
+        """
+        url = self._url(f"/api/v1/orchestrate-auto/stop/{session_id}")
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.post(url, headers=self._headers)
+            _check_status(resp.status_code, url)
+            return OrchestrateAutoStopResponse(**resp.json())
         except (BackendAuthFailed, BackendVersionTooOld):
             raise
         except Exception as exc:
             raise BackendUnreachable(self._base_url, str(exc)) from exc
 
+    async def orchestrate_auto_resume(
+        self,
+        session_id: str,
+        on_status_update=None,
+    ) -> OrchestrateAutoStatusResponse:
+        """POST /api/v1/orchestrate-auto/resume/{session_id} → poll status → OrchestrateAutoStatusResponse.
+
+        Resumes a paused pipeline session from its last LangGraph checkpoint —
+        no previously-completed steps are re-executed. Returns 202 immediately;
+        this method polls GET /api/v1/orchestrate-auto/status until the run is terminal.
+
+        on_status_update: optional async callable(auto_status: str, state: dict).
+        """
+        url = self._url(f"/api/v1/orchestrate-auto/resume/{session_id}")
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.post(url, headers=self._headers)
+            _check_status(resp.status_code, url)
+        except (BackendAuthFailed, BackendVersionTooOld):
+            raise
+        except Exception as exc:
+            raise BackendUnreachable(self._base_url, str(exc)) from exc
+
+        return await self._poll_auto_terminal(on_status_update)
+
+    async def orchestrate_auto_stop_all(self) -> OrchestrateAutoStopAllResponse:
+        """POST /api/v1/orchestrate-auto/stop — pause the WHOLE auto run.
+
+        The in-flight session is cancelled and checkpointed (paused), every
+        session still queued stays queued, and auto_status becomes `paused`.
+        Continue the run with orchestrate_auto_resume_all(). For pausing a
+        single session only, use orchestrate_auto_stop(session_id).
+        """
+        url = self._url("/api/v1/orchestrate-auto/stop")
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.post(url, headers=self._headers)
+            _check_status(resp.status_code, url)
+            return OrchestrateAutoStopAllResponse(**resp.json())
+        except (BackendAuthFailed, BackendVersionTooOld):
+            raise
+        except Exception as exc:
+            raise BackendUnreachable(self._base_url, str(exc)) from exc
+
+    async def orchestrate_auto_resume_all(
+        self,
+        on_status_update=None,
+    ) -> OrchestrateAutoStatusResponse:
+        """POST /api/v1/orchestrate-auto/resume → poll status → OrchestrateAutoStatusResponse.
+
+        Resumes the WHOLE auto run paused via orchestrate_auto_stop_all(): the
+        paused session continues from its LangGraph checkpoint (no steps
+        re-executed), then the remaining queued sessions run in their original
+        order; already-completed sessions are skipped. Returns 202 immediately;
+        this method polls GET /api/v1/orchestrate-auto/status until terminal.
+
+        on_status_update: optional async callable(auto_status: str, state: dict).
+        """
+        url = self._url("/api/v1/orchestrate-auto/resume")
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.post(url, headers=self._headers)
+            _check_status(resp.status_code, url)
+        except (BackendAuthFailed, BackendVersionTooOld):
+            raise
+        except Exception as exc:
+            raise BackendUnreachable(self._base_url, str(exc)) from exc
+
+        return await self._poll_auto_terminal(on_status_update)
+
+    async def _orchestrate_auto_status(self) -> dict:
+        """GET /api/v1/orchestrate-auto/status"""
+        async with httpx.AsyncClient(timeout=15.0) as client:
+            resp = await client.get(
+                self._url("/api/v1/orchestrate-auto/status"),
+                headers=self._headers,
+            )
+        _check_status(resp.status_code, self._base_url)
+        return resp.json()
+
     async def approve_task(self, task_id: str, decision: str, note: str = "") -> dict:
         async with httpx.AsyncClient(timeout=15.0) as client:
             resp = await client.post(
@@ -290,6 +528,42 @@ class BackendClient:
         _check_status(resp.status_code, self._base_url)
         return resp.json()
 
+    async def approval_reply(
+        self,
+        task_id: str,
+        decision: str = "APPROVED",
+        *,
+        local_execution_result: dict | None = None,
+        approver_role: str = "TEAM_LEAD",
+        approver_name: str = "Desktop",
+        raw_reply: str = "",
+    ) -> dict:
+        """POST /api/v1/webhooks/approval-reply — resume a System-B run after approval.
+
+        Auth uses the same co_ token (accepted by the endpoint's task-token path).
+        For the local-execution hybrid, pass ``local_execution_result`` so the
+        server injects the desktop's locally-produced result instead of
+        dispatching agents on the server.
+        """
+        body: dict = {
+            "taskId": task_id,
+            "approvalId": "desktop-local",
+            "decision": decision,
+            "approverRole": approver_role,
+            "approverName": approver_name,
+            "rawReply": raw_reply or f"{decision} (desktop local execution)",
+        }
+        if local_execution_result is not None:
+            body["localExecutionResult"] = local_execution_result
+        async with httpx.AsyncClient(timeout=20.0) as client:
+            resp = await client.post(
+                self._url("/api/v1/webhooks/approval-reply"),
+                json=body,
+                headers=self._headers,
+            )
+        _check_status(resp.status_code, self._base_url)
+        return resp.json()
+
     # ── Tasks ──────────────────────────────────────────────────────────
 
     async def list_tasks(

{devops_bot_sdk-1.2.0 → devops_bot_sdk-1.4.0}/sdk/config.py

@@ -115,6 +115,9 @@ def get_token() -> str:
 
 def configure_cli(rotate: bool = False) -> None:
     """Interactive `agentos configure` — paste your apiTokenHash once."""
+    if not rotate:
+        rotate = "--rotate" in sys.argv
+
     print("AgentOS SDK — Configuration")
     print("=" * 40)