devops-bot-sdk 1.4.27__tar.gz → 1.4.31__tar.gz

{devops_bot_sdk-1.4.27 → devops_bot_sdk-1.4.31}/PKG-INFO

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

{devops_bot_sdk-1.4.27 → devops_bot_sdk-1.4.31}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.27 → devops_bot_sdk-1.4.31}/pyproject.toml

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

{devops_bot_sdk-1.4.27 → devops_bot_sdk-1.4.31}/sdk/__init__.py

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

{devops_bot_sdk-1.4.27 → devops_bot_sdk-1.4.31}/sdk/client.py

@@ -36,7 +36,7 @@ from sdk.sse import _check_status, stream_with_reconnect
 
 logger = logging.getLogger(__name__)
 
-SDK_VERSION    = "1.4.27"
+SDK_VERSION    = "1.4.31"
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
 _ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time
@@ -691,6 +691,33 @@ class BackendClient:
             logger.warning("client.move_to_backlog error task=%s err=%s", task_id, exc)
             return False
 
+    async def move_to_todo(self, task_id: str) -> bool:
+        """PUT {BE}/tasks-ml/{id} status="To Do" (best-effort).
+
+        Used by `agentos-auto stop` to return the in-flight ticket to the unstarted
+        queue so a later run re-picks it up from scratch (rather than leaving it
+        In Progress). Returns True on success; logs and returns False otherwise.
+        """
+        from sdk.config import BE_DEFAULT_URL
+
+        url = f"{BE_DEFAULT_URL.rstrip('/')}/tasks-ml/{task_id}"
+        headers = {
+            k: v for k, v in self._headers.items() if k.lower() != "content-type"
+        }
+        headers.update({"accept": "*/*", "developer-name": "null", "product": ""})
+        try:
+            async with httpx.AsyncClient(timeout=20.0) as client:
+                resp = await client.put(url, files={"status": (None, "To Do")}, headers=headers)
+            if resp.status_code >= 400:
+                logger.warning("client.move_to_todo failed task=%s status=%s body=%s",
+                               task_id, resp.status_code, resp.text[:200])
+                return False
+            await self.log_activity(f"Task {task_id}: status → To Do")
+            return True
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.move_to_todo error task=%s err=%s", task_id, exc)
+            return False
+
     async def mark_in_progress(self, task_id: str) -> bool:
         """PUT {BE}/tasks-ml/{id} status=In Progress (best-effort).
 

{devops_bot_sdk-1.4.27 → devops_bot_sdk-1.4.31}/sdk/ipc/handlers.py

@@ -1845,31 +1845,45 @@ async def handle_orchestrate_auto_local_run(
                                   "current_step": f"{jira_key}: awaiting approval"},
                         ).model_dump())
 
-                        # Safety net for the gate-1 WhatsApp. The backend sends it
-                        # when planning opens the gate; if that send failed the
-                        # approver would get nothing and the ticket would silently
-                        # time out to Backlog. Re-send it ourselves once, only after
-                        # the grace window, so a healthy backend doesn't duplicate.
                         _wa_summary = task.get("summary") or jira_key or "task"
 
-                        async def _first_gate_wa_fallback(
+                        async def _send_first_gate_wa(
                             tid=tid, jira_key=jira_key, _wa_summary=_wa_summary,
-                        ) -> None:
-                            await send(Envelope(
-                                type="step_update", thread_id=thread_id,
-                                data={"current_step": f"{jira_key}: no approval reply yet — "
-                                                      "re-sending WhatsApp approval request"},
-                            ).model_dump())
-                            await client.notify_whatsapp(
+                        ) -> bool:
+                            # approver_role defaults to TEAM_LEAD (matches the ML
+                            # backend's /approvals-ml routing that is known to work).
+                            # Log the outcome to the daemon log + activity DB so a
+                            # failed send is visible instead of silently swallowed.
+                            ok = await client.notify_whatsapp(
                                 tid,
                                 f"Approval needed for {jira_key or tid}: {_wa_summary} — "
                                 "reply on WhatsApp to approve or reject so the work can start.",
                                 summary=_wa_summary,
                             )
+                            note = ("WhatsApp approval request sent" if ok
+                                    else "WhatsApp approval request FAILED to send "
+                                         "(check /approvals-ml + approver phone on file)")
+                            await send(Envelope(
+                                type="step_update", thread_id=thread_id,
+                                data={"current_step": f"{jira_key}: {note}"},
+                            ).model_dump())
+                            try:
+                                await client.log_activity(f"Task {tid}: {note}")
+                            except Exception:  # noqa: BLE001
+                                pass
+                            return ok
+
+                        # Send the gate-1 WhatsApp NOW via /approvals-ml (the ML
+                        # backend actually delivers it). Owning the send here makes
+                        # it reliable regardless of whether the AI backend's own
+                        # M5.2 send fired — the previous "no WhatsApp at all" bug.
+                        await _send_first_gate_wa()
 
+                        # Re-send once, after the grace window, only if still unanswered
+                        # (covers a transient failure of the send above).
                         decision = await _poll_approval(
                             client, tid, should_stop,
-                            fallback_notify=_first_gate_wa_fallback,
+                            fallback_notify=_send_first_gate_wa,
                             fallback_after_s=_FIRST_GATE_WA_FALLBACK_S,
                         )
 

{devops_bot_sdk-1.4.27 → devops_bot_sdk-1.4.31}/sdk/run_auto.py

@@ -28,11 +28,11 @@ Auto-update: on `run`/`resume`, the SDK checks for a newer version and upgrades
 itself (then re-runs on the new code) BEFORE detaching, so non-technical users
 never reinstall.
 
-Stop/resume model: the loop marks each task In Progress/Done on the backend as
-it goes, so the backend task status IS the saved state. `stop` writes a flag the
-running loop checks between tasks (so a stop takes effect after the in-flight
-task finishes); `resume` (or just re-running) clears the flag and continues with
-whatever is still To Do.
+Stop model: `stop` is immediate — it kills the loop's whole process group (the
+daemon and any child `claude`) and returns the in-flight ticket to "To Do" so a
+later run restarts it cleanly, rather than pausing after the current task. The
+tracked in-flight ticket id is kept in ~/.agentos/auto.current. `resume` (or just
+re-running) starts fresh over whatever is still To Do.
 """
 from __future__ import annotations
 
@@ -46,6 +46,9 @@ _AGENTOS_DIR = Path.home() / ".agentos"
 _STOP_FILE = _AGENTOS_DIR / "auto.stop"
 _PID_FILE = _AGENTOS_DIR / "auto.pid"
 _LOG_FILE = _AGENTOS_DIR / "auto.log"
+# Backend id (UUID) of the ticket currently being processed. `stop` reads it to
+# return the in-flight ticket to "To Do" before killing the loop.
+_CURRENT_FILE = _AGENTOS_DIR / "auto.current"
 
 
 def _stop_requested() -> bool:
@@ -64,6 +67,29 @@ def _clear_stop() -> None:
         pass
 
 
+def _write_current(task_id: str) -> None:
+    try:
+        _AGENTOS_DIR.mkdir(parents=True, exist_ok=True)
+        _CURRENT_FILE.write_text(task_id)
+    except Exception:  # noqa: BLE001
+        pass
+
+
+def _read_current() -> str | None:
+    try:
+        val = _CURRENT_FILE.read_text().strip()
+        return val or None
+    except FileNotFoundError:
+        return None
+
+
+def _clear_current() -> None:
+    try:
+        _CURRENT_FILE.unlink()
+    except FileNotFoundError:
+        pass
+
+
 # ── Background-daemon support ─────────────────────────────────────────────
 # `agentos-auto` must keep running after the terminal is closed and stop ONLY on
 # `agentos-auto stop`. We fully detach from the controlling terminal (double-fork
@@ -134,6 +160,14 @@ def _daemonize() -> bool:
     os.close(devnull)
     os.close(logfd)
 
+    # CRITICAL: when stdout is a file (not a tty) Python block-buffers it, so
+    # progress printed via _send() would sit in the buffer and never reach the
+    # log until the process exits — making the daemon look idle. Replace the
+    # streams with line-buffered writers so every progress line is flushed live,
+    # exactly like the foreground run.
+    sys.stdout = open(_LOG_FILE, "a", buffering=1, encoding="utf-8")
+    sys.stderr = sys.stdout
+
     _PID_FILE.write_text(str(os.getpid()))
     return True
 
@@ -149,9 +183,24 @@ def _parse_workspace_root(argv: list[str]) -> str | None:
     return None
 
 
+_current_task: str | None = None
+
+
 async def _send(env: dict) -> None:
     etype = env.get("type", "")
     data = env.get("data", {}) or {}
+
+    # Track the in-flight ticket (backend UUID) so `stop` can return it to To Do.
+    # The handler tags per-task envelopes with jira_task_id / task_id (both = the
+    # backend UUID here). Persist only on change to avoid churning the file.
+    global _current_task
+    tid = data.get("jira_task_id") or data.get("task_id")
+    if tid and tid != _current_task:
+        _current_task = tid
+        _write_current(tid)
+    if etype == "done":
+        _clear_current()
+
     if etype == "pipeline_started":
         print(f"\n▶ orchestrate-auto (local) — {data.get('task_count', 0)} task(s)\n")
     elif etype == "step_update":
@@ -205,12 +254,14 @@ def _run_loop(workspace_root: str | None) -> None:
         print("\n⏸ interrupted — stop flag set. run `agentos-auto resume` to continue.")
     finally:
         # Whether the loop finished, paused, or crashed, drop our PID file so
-        # `status` doesn't report a dead daemon as running.
+        # `status` doesn't report a dead daemon as running, and clear the
+        # in-flight marker (the queue is drained on a clean finish).
         if _read_pid() == os.getpid():
             try:
                 _PID_FILE.unlink()
             except FileNotFoundError:
                 pass
+        _clear_current()
 
 
 def main() -> None:
@@ -225,13 +276,63 @@ def main() -> None:
         return
 
     if cmd == "stop":
+        # Hard stop: halt the current task immediately, return it to To Do so it
+        # restarts cleanly next run, and kill the whole loop (not a cooperative
+        # pause after the current task).
         _set_stop()
         pid = _daemon_running()
+        cur = _read_current()
+
+        # 1. Kill the loop's ENTIRE process group first (daemon + any child
+        #    `claude` it spawned) so nothing keeps mutating the ticket. The daemon
+        #    is a session leader (setsid), so its PGID == its PID.
         if pid:
-            print(f"stop requested — the background loop (pid {pid}) will pause after "
-                  "the current task, then exit.")
+            import signal
+            import time as _t
+            # Kill the whole process group ONLY when pid is its own group leader
+            # (the daemon, via setsid) — that also reaps the child `claude`. For a
+            # foreground run (shares the shell's group) fall back to a single kill
+            # so we don't take down the user's terminal.
+            try:
+                is_group_leader = os.getpgid(pid) == pid
+            except ProcessLookupError:
+                is_group_leader = False
+            killed = False
+            for sig in (signal.SIGTERM, signal.SIGKILL):
+                try:
+                    if is_group_leader:
+                        os.killpg(pid, sig)
+                    else:
+                        os.kill(pid, sig)
+                except ProcessLookupError:
+                    killed = True
+                    break
+                except Exception:  # noqa: BLE001
+                    pass
+                _t.sleep(1.5)
+                if not _pid_alive(pid):
+                    killed = True
+                    break
+            print(f"stopped background loop (pid {pid})" if killed
+                  else f"sent stop signals to pid {pid}")
         else:
-            print("stop requested — a running `agentos-auto` will pause after the current task.")
+            print("no background loop running — stop flag set for any foreground run.")
+
+        # 2. Now that the loop is dead, move the in-flight ticket back to To Do.
+        if cur:
+            try:
+                from sdk.client import BackendClient
+                ok = asyncio.run(BackendClient.from_config().move_to_todo(cur))
+                print(f"in-flight ticket → To Do ({'ok' if ok else 'failed'})")
+            except Exception as exc:  # noqa: BLE001
+                print(f"warning: could not move in-flight ticket to To Do ({exc})")
+
+        # 3. Clean up state files.
+        for f in (_PID_FILE, _CURRENT_FILE):
+            try:
+                f.unlink()
+            except FileNotFoundError:
+                pass
         return
 
     if cmd == "status":
@@ -239,12 +340,24 @@ def main() -> None:
         if pid:
             print(f"background loop: running (pid {pid})")
             print(f"logs: {_LOG_FILE}")
+            cur = _read_current()
+            if cur:
+                print(f"current ticket: {cur}")
         else:
             print("background loop: not running")
         print("stop pending: yes" if _stop_requested() else "stop pending: no")
         return
 
     if cmd in ("run", "resume"):
+        # Self-update FIRST (before the already-running check) so the installed
+        # package is refreshed even when a daemon is already running — otherwise a
+        # long-lived old daemon would pin `stop`/`status` to a stale version. Runs
+        # in the FOREGROUND so the user sees update output; re-execs on the new
+        # code. Skipped with --no-update or AGENTOS_NO_UPDATE=1.
+        if "--no-update" not in argv:
+            from sdk.updater import auto_update_and_reexec
+            auto_update_and_reexec("sdk.run_auto", sys.argv[1:])
+
         # Refuse to start a second loop — one background daemon owns the To Do queue.
         pid = _daemon_running()
         if pid:
@@ -253,13 +366,6 @@ def main() -> None:
             print("  stop:   agentos-auto stop")
             return
 
-        # Keep non-technical users current: self-update, then re-run on the new
-        # code. Runs in the FOREGROUND (before detaching) so the user sees update
-        # output. Skipped with --no-update or AGENTOS_NO_UPDATE=1.
-        if "--no-update" not in argv:
-            from sdk.updater import auto_update_and_reexec
-            auto_update_and_reexec("sdk.run_auto", sys.argv[1:])
-
         workspace_root = _parse_workspace_root(argv)
 
         # Background by default: detach so closing the terminal (SIGHUP) can't kill