devops-bot-sdk 1.4.29__tar.gz → 1.4.33__tar.gz

{devops_bot_sdk-1.4.29 → devops_bot_sdk-1.4.33}/PKG-INFO

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

{devops_bot_sdk-1.4.29 → devops_bot_sdk-1.4.33}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.29 → devops_bot_sdk-1.4.33}/pyproject.toml

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

{devops_bot_sdk-1.4.29 → devops_bot_sdk-1.4.33}/sdk/__init__.py

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

{devops_bot_sdk-1.4.29 → devops_bot_sdk-1.4.33}/sdk/client.py

@@ -36,7 +36,29 @@ from sdk.sse import _check_status, stream_with_reconnect
 
 logger = logging.getLogger(__name__)
 
-SDK_VERSION    = "1.4.29"
+# ── Ticket status-change observers ────────────────────────────────────────
+# Best-effort, synchronous hooks fired when the client changes a ticket's backend
+# status (In Progress / Backlog / To Do). The CLI loop registers one to track
+# which tickets the run has parked in Backlog, so `agentos-auto stop` can restore
+# exactly those to To Do. Kept generic here — the client never touches CLI files.
+_status_observers: list = []
+
+
+def register_status_observer(cb) -> None:
+    """Register cb(task_id: str, status: str) — status ∈ {in_progress, backlog, to_do}."""
+    if cb not in _status_observers:
+        _status_observers.append(cb)
+
+
+def _notify_status(task_id: str, status: str) -> None:
+    for cb in list(_status_observers):
+        try:
+            cb(task_id, status)
+        except Exception:  # noqa: BLE001 — observers must never break a request
+            pass
+
+
+SDK_VERSION    = "1.4.33"
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
 _ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time
@@ -686,11 +708,40 @@ class BackendClient:
                                task_id, resp.status_code, resp.text[:200])
                 return False
             await self.log_activity(f"Task {task_id}: status → Backlog")
+            _notify_status(task_id, "backlog")
             return True
         except Exception as exc:  # noqa: BLE001
             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")
+            _notify_status(task_id, "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).
 
@@ -712,6 +763,7 @@ class BackendClient:
                                task_id, resp.status_code, resp.text[:200])
                 return False
             await self.log_activity(f"Task {task_id}: status → In Progress")
+            _notify_status(task_id, "in_progress")
             return True
         except Exception as exc:  # noqa: BLE001
             logger.warning("client.mark_in_progress error task=%s err=%s", task_id, exc)

{devops_bot_sdk-1.4.29 → devops_bot_sdk-1.4.33}/sdk/run_auto.py

@@ -28,11 +28,13 @@ 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`), then returns to "To Do" both the in-flight ticket
+AND every ticket this run parked in Backlog (e.g. 15-min approval timeouts), so a
+later run re-attempts them; human-parked Backlog tickets are left untouched. The
+in-flight id is kept in ~/.agentos/auto.current and the run's Backlog set in
+~/.agentos/auto.backlogged (maintained via a client status observer). `resume`
+(or just re-running) starts fresh over whatever is still To Do.
 """
 from __future__ import annotations
 
@@ -46,6 +48,13 @@ _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"
+# Backend ids the CURRENT run has moved to Backlog (e.g. 15-min approval
+# timeouts). `stop` restores exactly these to "To Do" too — not human-parked
+# Backlog tickets. Maintained live via a client status observer.
+_BACKLOGGED_FILE = _AGENTOS_DIR / "auto.backlogged"
 
 
 def _stop_requested() -> bool:
@@ -64,6 +73,64 @@ 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
+
+
+def _read_backlogged() -> set[str]:
+    try:
+        return set(json.loads(_BACKLOGGED_FILE.read_text()))
+    except (FileNotFoundError, ValueError, TypeError):
+        return set()
+
+
+def _write_backlogged(ids: set[str]) -> None:
+    try:
+        _AGENTOS_DIR.mkdir(parents=True, exist_ok=True)
+        _BACKLOGGED_FILE.write_text(json.dumps(sorted(ids)))
+    except Exception:  # noqa: BLE001
+        pass
+
+
+def _clear_backlogged() -> None:
+    try:
+        _BACKLOGGED_FILE.unlink()
+    except FileNotFoundError:
+        pass
+
+
+def _track_status(task_id: str, status: str) -> None:
+    """Client status observer (runs in the daemon): keep the set of tickets THIS
+    run has parked in Backlog current, so `stop` can restore them to To Do."""
+    if not task_id:
+        return
+    ids = _read_backlogged()
+    if status == "backlog":
+        ids.add(task_id)
+    else:  # in_progress / to_do → no longer backlogged by us
+        ids.discard(task_id)
+    _write_backlogged(ids)
+
+
 # ── 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
@@ -157,9 +224,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":
@@ -183,7 +265,7 @@ async def _send(env: dict) -> None:
 
 def _run_loop(workspace_root: str | None) -> None:
     from sdk import local_exec
-    from sdk.client import BackendClient
+    from sdk.client import BackendClient, register_status_observer
     from sdk.ipc import handlers
 
     if not local_exec.is_available():
@@ -202,6 +284,8 @@ def _run_loop(workspace_root: str | None) -> None:
         payload["workspace_root"] = workspace_root
 
     _clear_stop()  # a fresh run/resume clears any stale stop flag
+    _clear_backlogged()  # session-scoped: only track Backlog moves from THIS run
+    register_status_observer(_track_status)  # keep the run's Backlog set current
     try:
         asyncio.run(
             handlers.handle_orchestrate_auto_local_run(
@@ -213,12 +297,15 @@ 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
+        # + backlog markers (a clean finish leaves nothing for `stop` to restore).
         if _read_pid() == os.getpid():
             try:
                 _PID_FILE.unlink()
             except FileNotFoundError:
                 pass
+        _clear_current()
+        _clear_backlogged()
 
 
 def main() -> None:
@@ -226,20 +313,98 @@ def main() -> None:
     cmd = argv[0] if argv and not argv[0].startswith("-") else "run"
 
     if cmd == "update":
-        from sdk.updater import auto_update
-        updated, cur, latest = auto_update(quiet=False)
-        if not updated:
-            print(f"already up to date (v{cur})" if latest else f"v{cur} (could not reach PyPI)")
+        # Update-only: upgrade the installed SDK package to the latest version and
+        # report before → after. Does NOT start, stop, or touch the running loop —
+        # a running daemon keeps its current code until it is restarted. Honours
+        # AGENTOS_NO_UPDATE=1 (auto_update no-ops).
+        from sdk.updater import auto_update, current_version
+        before = current_version()
+        print("checking for SDK updates …")
+        auto_update(quiet=True)
+        after = current_version()
+        if after != before:
+            print(f"✓ updated {before} → {after}")
+            pid = _daemon_running()
+            if pid:
+                print("note: a background loop is running the OLD version — "
+                      "`agentos-auto stop` then `agentos-auto` to run the new one.")
+        else:
+            print(f"already up to date (v{after})")
         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()
+        backlogged = _read_backlogged()  # tickets THIS run parked in Backlog
+
+        # 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 AND every ticket
+        #    this run parked in Backlog (e.g. 15-min approval timeouts) back to
+        #    To Do, so a later run re-attempts them. Human-parked Backlog tickets
+        #    are untouched — only ids this run recorded are restored.
+        to_restore = [t for t in ({cur} | backlogged) if t]
+        if to_restore:
+            async def _restore(ids: list[str]) -> int:
+                from sdk.client import BackendClient
+                client = BackendClient.from_config()
+                done = 0
+                for t in ids:
+                    try:
+                        if await client.move_to_todo(t):
+                            done += 1
+                    except Exception:  # noqa: BLE001
+                        pass
+                return done
+            try:
+                n = asyncio.run(_restore(to_restore))
+                print(f"restored {n}/{len(to_restore)} ticket(s) → To Do")
+            except Exception as exc:  # noqa: BLE001
+                print(f"warning: could not restore tickets to To Do ({exc})")
+
+        # 3. Clean up state files.
+        for f in (_PID_FILE, _CURRENT_FILE, _BACKLOGGED_FILE):
+            try:
+                f.unlink()
+            except FileNotFoundError:
+                pass
         return
 
     if cmd == "status":
@@ -247,12 +412,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:
@@ -261,13 +438,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