devops-bot-sdk 1.4.17__tar.gz → 1.4.20__tar.gz

{devops_bot_sdk-1.4.17 → devops_bot_sdk-1.4.20}/PKG-INFO

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

{devops_bot_sdk-1.4.17 → devops_bot_sdk-1.4.20}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.17 → devops_bot_sdk-1.4.20}/pyproject.toml

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

{devops_bot_sdk-1.4.17 → devops_bot_sdk-1.4.20}/sdk/__init__.py

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

{devops_bot_sdk-1.4.17 → devops_bot_sdk-1.4.20}/sdk/client.py

@@ -36,7 +36,7 @@ from sdk.sse import _check_status, stream_with_reconnect
 
 logger = logging.getLogger(__name__)
 
-SDK_VERSION    = "1.4.17"
+SDK_VERSION    = "1.4.20"
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
 _ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time
@@ -685,11 +685,66 @@ class BackendClient:
                 logger.warning("client.move_to_backlog 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 → 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 mark_in_progress(self, task_id: str) -> bool:
+        """PUT {BE}/tasks-ml/{id} status=In Progress (best-effort).
+
+        Called at the start of processing to move the ticket from To Do to
+        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, "In Progress")}, headers=headers)
+            if resp.status_code >= 400:
+                logger.warning("client.mark_in_progress 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 → In Progress")
+            return True
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.mark_in_progress error task=%s err=%s", task_id, exc)
+            return False
+
+    async def log_activity(self, activity: str) -> bool:
+        """POST /ml-api/agent-activity — emit an agent activity event (best-effort).
+
+        Called on status transitions (In Progress, Backlog), every 4 files written
+        during local execution, and on errors. Never raises so a log failure can't
+        break a run.
+        """
+        from sdk.config import BE_DEFAULT_URL
+
+        url = f"{BE_DEFAULT_URL.rstrip('/')}/ml-api/agent-activity"
+        headers = {
+            **self._headers,
+            "accept": "*/*",
+            "developer-name": "null",
+            "product": "",
+        }
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                resp = await client.post(url, json={"activity": str(activity)}, headers=headers)
+            if resp.status_code >= 400:
+                logger.warning("client.log_activity failed status=%s body=%s",
+                               resp.status_code, resp.text[:200])
+                return False
+            return True
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.log_activity error err=%s", exc)
+            return False
+
     async def notify_whatsapp(
         self,
         task_id: str,

{devops_bot_sdk-1.4.17 → devops_bot_sdk-1.4.20}/sdk/ipc/handlers.py

@@ -438,7 +438,10 @@ async def _code_one_repo(
     # 0. Make sure the repo is present (clone from repo_url only if missing/empty).
     await git_ops.ensure_repo(repo_path, repo_url, gh_token)
 
+    _write_count = 0
+
     async def _on_event(event: dict) -> None:
+        nonlocal _write_count
         if event.get("type") == "assistant":
             for c in event.get("message", {}).get("content", []):
                 if c.get("type") == "tool_use":
@@ -450,6 +453,14 @@ async def _code_one_repo(
                         data={"status": "running", "current_step": label},
                     ).model_dump())
                     if tname in ("Write", "Edit", "MultiEdit"):
+                        _write_count += 1
+                        if _write_count % 4 == 0:
+                            try:
+                                await client.log_activity(
+                                    f"Task {task_id} [{name}]: {_write_count} files written"
+                                )
+                            except Exception:  # noqa: BLE001
+                                pass
                         try:
                             from sdk import graphify
                             graphify.schedule_update(repo_path)
@@ -659,6 +670,11 @@ async def handle_pipeline_approve(
         return
 
     # ── Approved: run the local claude CLI on EACH repo the ticket names ──
+    # Mark back to In Progress — covers both direct approval in the auto-loop
+    # and a resume that arrives after the ticket sat in Backlog waiting for
+    # the human's WhatsApp reply or a usage-limit window reset.
+    await client.mark_in_progress(task_id)
+
     # The prompt is built per-repo inside _code_one_repo so its framing matches
     # whether that target is a git repo (branch + PR) or a plain local folder.
     agent_mode = bool(pending.get("agent_mode", True))
@@ -765,10 +781,13 @@ async def handle_pipeline_approve(
             await client.notify_whatsapp(task_id, note, summary="AgentOS local run alert")
         except Exception:  # noqa: BLE001
             pass
+        await client.log_activity(f"Task {task_id}: local execution failed — {err[:300]}")
+        await client.move_to_backlog(task_id)
         await send(Envelope(
             type=Envelope.TYPE_ERROR, thread_id=thread_id,
             data={"code": "LOCAL_EXEC_FAILED", "message": err[:300], "task_id": task_id},
         ).model_dump())
+        return
 
     # ── Finalize on the server once per task (validation + Jira/cost) ─────
     await send(Envelope(
@@ -786,6 +805,8 @@ async def handle_pipeline_approve(
             },
         )
     except Exception as exc:
+        await client.log_activity(f"Task {task_id}: server finalization failed — {str(exc)[:200]}")
+        await client.move_to_backlog(task_id)
         await send(_error_envelope(thread_id, exc).model_dump())
         return
 
@@ -1500,9 +1521,11 @@ def _resolve_local_project_path(task: dict, payload: dict) -> str:
     return str(Path(root).expanduser() / key)
 
 
-# Approval polling cadence for the first-approval gate (agentMode=true). The
-# 20-min timeout matches the backend's own Backlog demotion timer.
+# Approval polling cadence for the first-approval gate (agentMode=true).
+# _FIRST_GATE_TIMEOUT_S: ticket moves to Backlog after 15 min with no reply.
+# _APPROVAL_POLL_TIMEOUT_S: longer timeout kept for mid-run crucial-decision gates.
 _APPROVAL_POLL_INTERVAL_S = 15.0
+_FIRST_GATE_TIMEOUT_S = 900.0
 _APPROVAL_POLL_TIMEOUT_S = 1200.0
 # Max times a single ticket's session is resumed after a context overflow.
 _MAX_CONTEXT_RESUMES = 3
@@ -1551,9 +1574,10 @@ async def _poll_approval(
 
     Returns 'approved' | 'rejected' | 'stopped' | 'timeout'. The decision is the
     human's WhatsApp reply, recorded backend-side under approval_log:{task_id}.
+    Times out after _FIRST_GATE_TIMEOUT_S (15 min) so the ticket can move to Backlog.
     """
     waited = 0.0
-    while waited < _APPROVAL_POLL_TIMEOUT_S:
+    while waited < _FIRST_GATE_TIMEOUT_S:
         if should_stop is not None and should_stop():
             return "stopped"
         status = await client.approval_status(task_id)
@@ -1589,6 +1613,53 @@ async def _poll_fresh_approval(
     return "timeout"
 
 
+async def _background_approval_watcher(
+    client: BackendClient,
+    session_id: str,
+    task_id: str,
+    jira_key: str,
+    thread_id: str,
+    send: Callable,
+    should_stop: Callable[[], bool] | None,
+) -> None:
+    """Poll indefinitely for a late approval on a timed-out gate, then resume.
+
+    Spawned as a fire-and-forget task when the first-gate 15-min timeout fires.
+    When the user approves (via WhatsApp), calls handle_pipeline_approve so the
+    ticket resumes from exactly where it paused. handle_pipeline_approve already
+    calls mark_in_progress, so the Jira status flips In Progress → Backlog →
+    In Progress automatically. Cleans up _PENDING_LOCAL on any terminal outcome.
+    """
+    try:
+        while True:
+            if should_stop is not None and should_stop():
+                return
+            status = await client.approval_status(task_id)
+            if status == "approved":
+                break
+            if status == "rejected":
+                await send(Envelope(
+                    type="step_update", thread_id=thread_id,
+                    data={"current_step": f"{jira_key}: rejected (late approval) — skipped"},
+                ).model_dump())
+                return
+            await asyncio.sleep(_APPROVAL_POLL_INTERVAL_S)
+        # Approval arrived — move back to In Progress and resume execution.
+        await send(Envelope(
+            type="step_update", thread_id=thread_id,
+            data={"current_step": f"{jira_key}: late approval received — resuming from Backlog"},
+        ).model_dump())
+        await handle_pipeline_approve(
+            client,
+            {"session_id": session_id, "decision": "approved", "thread_id": thread_id},
+            send,
+        )
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("background_approval_watcher.failed task=%s err=%s", task_id, exc)
+    finally:
+        _PENDING_LOCAL.pop(session_id, None)
+
+
 async def handle_orchestrate_auto_local_run(
     client: BackendClient, payload: dict, send: Callable,
     should_stop: Callable[[], bool] | None = None,
@@ -1680,6 +1751,9 @@ async def handle_orchestrate_auto_local_run(
                 attempt = 0
                 while True:
                     attempt += 1
+                    # Mark In Progress before any work begins so Jira reflects
+                    # the real state even if the run fails partway through.
+                    await client.mark_in_progress(tid)
                     # Phase 1 — server plans + gates. NO local code/bash runs yet.
                     await _run_local_pipeline(client, task_payload, send)
                     session_id = next(
@@ -1711,6 +1785,20 @@ async def handle_orchestrate_auto_local_run(
                                       "processed": processed, "task_count": total},
                             ).model_dump())
                             return
+                        if decision == "timeout":
+                            # 15 min elapsed — move to Backlog but keep _PENDING_LOCAL
+                            # alive, then spawn a background watcher that polls until
+                            # the user approves and resumes execution automatically.
+                            await client.move_to_backlog(tid)
+                            await send(Envelope(
+                                type="step_update", thread_id=thread_id,
+                                data={"current_step": f"{jira_key}: no approval in 15m — moved to Backlog"
+                                                      " (background watcher will auto-resume on approval)"},
+                            ).model_dump())
+                            asyncio.ensure_future(_background_approval_watcher(
+                                client, session_id, tid, jira_key, thread_id, send, should_stop,
+                            ))
+                            break
                         if decision != "approved":
                             _PENDING_LOCAL.pop(session_id, None)
                             await send(Envelope(
@@ -1756,6 +1844,8 @@ async def handle_orchestrate_auto_local_run(
                     break
             except Exception as exc:  # noqa: BLE001 — isolate per-ticket failures
                 logger.warning("orchestrate_auto.task_failed", extra={"task_id": tid, "error": str(exc)})
+                await client.log_activity(f"Task {tid}: unexpected error — {str(exc)[:200]}")
+                await client.move_to_backlog(tid)
                 await send(Envelope(
                     type="step_update", thread_id=thread_id,
                     data={"current_step": f"{jira_key or tid}: failed — {str(exc)[:160]} (continuing)"},

{devops_bot_sdk-1.4.17 → devops_bot_sdk-1.4.20}/sdk/local_exec.py

@@ -22,6 +22,7 @@ import json
 import os
 import re
 import shutil
+import sys
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Awaitable, Callable
@@ -242,7 +243,6 @@ async def run_claude_local(
     # destructive tool calls are blocked until a human approves (the guard reads
     # AGENTOS_APPROVAL_DIR set below). Merges with any global/project hooks.
     if approval_dir:
-        import sys
         from sdk import crucial
         settings_path = os.path.join(approval_dir, "claude_settings.json")
         try:
@@ -271,8 +271,20 @@ async def run_claude_local(
     if approval_dir:
         env["AGENTOS_APPROVAL_DIR"] = approval_dir
 
+    # On Windows, npm/nvm install the CLI as a `.cmd`/`.bat` batch shim (e.g.
+    # claude.CMD). `create_subprocess_exec` calls CreateProcess directly — with NO
+    # command processor — and a batch shim launched that way can fail to bootstrap
+    # on some setups (notably nvm-for-Windows, where node lives behind a junction):
+    # it starts, emits nothing, and exits, surfacing here as "no result event".
+    # Route the shim through %COMSPEC% so it runs in a real cmd.exe exactly as an
+    # interactive shell would. Native `.exe` installs and POSIX paths spawn directly.
+    spawn_cmd = cmd
+    if sys.platform == "win32" and cli.lower().endswith((".cmd", ".bat")):
+        comspec = os.environ.get("COMSPEC", "cmd.exe")
+        spawn_cmd = [comspec, "/c", *cmd]
+
     proc = await asyncio.create_subprocess_exec(
-        *cmd,
+        *spawn_cmd,
         cwd=str(path),
         stdin=asyncio.subprocess.PIPE,
         stdout=asyncio.subprocess.PIPE,

{devops_bot_sdk-1.4.17 → devops_bot_sdk-1.4.20}/sdk/updater.py

@@ -183,43 +183,65 @@ def _fetch_github_token() -> str | None:
 
 # ── Core update logic ─────────────────────────────────────────────────────────
 
-def self_update() -> bool:
-    """Upgrade the installed SDK via pip. Returns True on success.
+def _install_candidates() -> list[str]:
+    """Ordered pip targets: detected URL → SSH → token-HTTPS branch → PyPI dist."""
+    cands = list(_unique([_detect_install_url(), _GITHUB_SSH]))
+    gh_token = _fetch_github_token()
+    if gh_token:
+        cands.append(f"git+https://{gh_token}@github.com/{_GITHUB_REPO}.git@{_sdk_branch()}")
+    cands.append(_DIST)
+    return cands
 
-    Tries candidates in order:
-      1. Original install URL (from direct_url.json)
-      2. GitHub SSH URL
-      3. GitHub HTTPS URL using token from /ml-api/github/token
-      4. PyPI dist name
-    Stops at the first success.
-    """
-    flags = _pip_flags()
 
-    def _pip_upgrade(url: str) -> bool:
-        try:
-            subprocess.run(
-                [sys.executable, "-m", "pip", "install",
-                 "--upgrade", "--quiet", *flags, url],
-                check=True, capture_output=True,
-            )
-            return True
-        except Exception:  # noqa: BLE001
-            return False
+def _pip_install(url: str, *, force: bool = False) -> bool:
+    """pip install --upgrade <url>. force=True adds --force-reinstall (repair)."""
+    extra = ["--force-reinstall", "--no-deps"] if force else []
+    try:
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--upgrade", "--quiet",
+             *extra, *_pip_flags(), url],
+            check=True, capture_output=True,
+        )
+        return True
+    except Exception:  # noqa: BLE001
+        return False
 
-    # 1 + 2: detected URL and SSH fallback
-    for url in _unique([_detect_install_url(), _GITHUB_SSH]):
-        if _pip_upgrade(url):
-            return True
 
-    # 3: token (env first, then backend) → HTTPS upgrade from the target branch
-    gh_token = _fetch_github_token()
-    if gh_token:
-        https_url = f"git+https://{gh_token}@github.com/{_GITHUB_REPO}.git@{_sdk_branch()}"
-        if _pip_upgrade(https_url):
+def _verify_install() -> bool:
+    """True if the installed SDK imports cleanly in a FRESH process.
+
+    Guards against a partial/corrupt upgrade — on Windows the running
+    ``agentos-auto.exe`` / loaded package files can't be replaced mid-pip, which
+    can leave ``sdk`` importable but missing submodules (e.g. local_exec)."""
+    try:
+        r = subprocess.run(
+            [sys.executable, "-c",
+             "import sdk, sdk.local_exec, sdk.ipc.handlers, sdk.run_auto"],
+            capture_output=True, timeout=90,
+        )
+        return r.returncode == 0
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def _repair_install() -> bool:
+    """Force-reinstall to recover from a corrupt upgrade; verifies the result."""
+    for url in _install_candidates():
+        if _pip_install(url, force=True) and _verify_install():
             return True
+    return False
+
+
+def self_update() -> bool:
+    """Upgrade the installed SDK via pip. Returns True on success.
 
-    # 4: bare PyPI name (last resort)
-    return _pip_upgrade(_DIST)
+    Tries candidates in order (detected URL → SSH → token-HTTPS → PyPI),
+    stopping at the first success.
+    """
+    for url in _install_candidates():
+        if _pip_install(url):
+            return True
+    return False
 
 
 def auto_update(quiet: bool = False) -> tuple[bool, str, str | None]:
@@ -274,6 +296,25 @@ def auto_update_and_reexec(module: str, argv: list[str]) -> None:
     if os.getenv("AGENTOS_NO_UPDATE") or os.getenv("_AGENTOS_REEXEC"):
         return
     updated, _cur, _latest = auto_update(quiet=False)
+
+    # A self-upgrade of a RUNNING package can land broken on Windows (the active
+    # agentos-auto.exe / loaded files can't be replaced mid-pip — pip uninstalls
+    # the old then can't write the new, leaving sdk partial or removed). NEVER run
+    # on a corrupt install: verify it imports, repair (force-reinstall) if not, and
+    # abort with manual instructions only if repair also fails.
+    if not _verify_install():
+        print("⚠ the SDK looks incomplete after update — repairing …")
+        if not _repair_install():
+            print(
+                "error: the SDK self-update left the install broken and auto-repair "
+                "failed.\n       reinstall it manually, then re-run agentos-auto:\n"
+                f'         "{sys.executable}" -m pip install --force-reinstall '
+                f'"git+https://github.com/{_GITHUB_REPO}.git@{_sdk_branch()}"'
+            )
+            sys.exit(1)
+        print("✓ repaired.")
+        updated = True   # repaired → restart on the fixed install
+
     if not updated:
         return
     print("restarting on the updated version …\n")