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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.31
+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.31 → 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.31
+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.31 → 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.31"
+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.31 → 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.31
+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.31"
+__version__ = "1.4.33"
 __author__  = "AgentOS"
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.4.31 → 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.31"
+# ── 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,6 +708,7 @@ 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)
@@ -713,6 +736,7 @@ class BackendClient:
                                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)
@@ -739,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.31 → devops_bot_sdk-1.4.33}/sdk/run_auto.py

@@ -29,10 +29,12 @@ itself (then re-runs on the new code) BEFORE detaching, so non-technical users
 never reinstall.
 
 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.
+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
 
@@ -49,6 +51,10 @@ _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:
@@ -90,6 +96,41 @@ def _clear_current() -> None:
         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
@@ -224,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():
@@ -243,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(
@@ -254,14 +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, and clear the
-        # in-flight marker (the queue is drained on a clean finish).
+        # `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:
@@ -269,10 +313,23 @@ 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":
@@ -282,6 +339,7 @@ def main() -> None:
         _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
@@ -318,17 +376,31 @@ def main() -> None:
         else:
             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:
+        # 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
-                ok = asyncio.run(BackendClient.from_config().move_to_todo(cur))
-                print(f"in-flight ticket → To Do ({'ok' if ok else 'failed'})")
+                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 move in-flight ticket to To Do ({exc})")
+                print(f"warning: could not restore tickets to To Do ({exc})")
 
         # 3. Clean up state files.
-        for f in (_PID_FILE, _CURRENT_FILE):
+        for f in (_PID_FILE, _CURRENT_FILE, _BACKLOGGED_FILE):
             try:
                 f.unlink()
             except FileNotFoundError: