devops-bot-sdk 1.6.38__tar.gz → 1.6.40__tar.gz

{devops_bot_sdk-1.6.38 → devops_bot_sdk-1.6.40}/PKG-INFO

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

{devops_bot_sdk-1.6.38 → devops_bot_sdk-1.6.40}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.38 → devops_bot_sdk-1.6.40}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ sdk/graphify.py
 sdk/intake.py
 sdk/journal.py
 sdk/local_exec.py
+sdk/memory_guard.py
 sdk/phase_timer.py
 sdk/plan_run.py
 sdk/platform_compat.py
@@ -140,7 +141,9 @@ tests/test_client_jira_projects.py
 tests/test_config_token_diagnostics.py
 tests/test_configure_token_owner.py
 tests/test_console_encoding.py
+tests/test_crash_recovery.py
 tests/test_departments.py
+tests/test_done_transition.py
 tests/test_epic_decompose_run.py
 tests/test_epic_inherited_agent_id.py
 tests/test_epic_session_isolation.py
@@ -158,10 +161,13 @@ tests/test_intake_job_outcome.py
 tests/test_intake_plan_review.py
 tests/test_journal.py
 tests/test_local_exec_provider.py
+tests/test_memory_guard.py
 tests/test_phase_timer.py
 tests/test_plan_new_command.py
 tests/test_plan_run_activity.py
+tests/test_pr_identity.py
 tests/test_prd_artifact.py
+tests/test_project_path_resolution.py
 tests/test_proof_readers.py
 tests/test_providers.py
 tests/test_recon_session_isolation.py
@@ -169,6 +175,7 @@ tests/test_resume.py
 tests/test_router.py
 tests/test_run_auto_agent_only.py
 tests/test_run_outputs.py
+tests/test_run_verdict_is_honest.py
 tests/test_schedule_api.py
 tests/test_scheduler.py
 tests/test_self_report.py
@@ -184,6 +191,8 @@ tests/test_ui_gate.py
 tests/test_ui_lifespan.py
 tests/test_update_timer.py
 tests/test_updater_extras.py
+tests/test_updater_reports_the_truth.py
 tests/test_url_access.py
 tests/test_vps_health.py
+tests/test_windows_loop_identity.py
 tests/test_write_hook.py

{devops_bot_sdk-1.6.38 → devops_bot_sdk-1.6.40}/sdk/__init__.py

@@ -34,7 +34,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.6.38"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.40"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
 __author__  = "AgentOS"   # sdk.client.SDK_VERSION and the UI server version all read this.
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.6.38 → devops_bot_sdk-1.6.40}/sdk/agentd.py

@@ -438,7 +438,31 @@ async def _dispatch_agent_run(
             from sdk import write_hook
             from sdk.agents.engines.claude_code import ensure_agent_workspace
 
-            _workspace = str(ensure_agent_workspace(manifest.name))
+            # Where the agent works. A TICKET-triggered run belongs in the repo the
+            # ticket names — this call site had the `task` all along and never passed
+            # it, so `claude_code.run` fell through to `ensure_agent_workspace()` and
+            # every agent-routed ticket wrote into `~/.agentos/runs/<agent>` on any
+            # drive and any OS, then reported success. A ticket that names nowhere,
+            # and every scheduled run, still gets the per-agent scratch directory:
+            # "summarise my PRs daily" has no repo and should not be given one.
+            _workspace = ""
+            if task:
+                try:
+                    from sdk.ipc.handlers import resolve_project_path
+                    _resolved = resolve_project_path(task, {})
+                    if _resolved.source == "instructions":
+                        _workspace = _resolved.path
+                    elif _resolved.unresolved:
+                        logger.warning(
+                            "agentd.project_path_unresolved agent=%s task=%s named=%s",
+                            manifest.name, task_id, _resolved.unresolved,
+                        )
+                except Exception as exc:  # noqa: BLE001 — never block a run on this
+                    logger.warning("agentd.project_path_failed task=%s err=%s",
+                                   task_id, exc)
+            if not _workspace:
+                _workspace = str(ensure_agent_workspace(manifest.name))
+
             _record_write = write_hook.make_recorder(
                 task_id=task_id or f"agent-{manifest.name}",
                 repo_path=_workspace,
@@ -452,7 +476,7 @@ async def _dispatch_agent_run(
             _started = time.monotonic()
             local_result = await claude_code_engine.run(
                 manifest, skill_text, mcp_config, extra_env=effective_secrets or None,
-                on_event=_tee,
+                on_event=_tee, project_path=_workspace,
             )
             run_log.finish_run(_log_path, local_result)
             # Backstop for writes the stream did not surface (a resumed turn,

{devops_bot_sdk-1.6.38 → devops_bot_sdk-1.6.40}/sdk/client.py

@@ -926,12 +926,18 @@ class BackendClient:
         except Exception:
             return "pending"
 
-    async def github_token_record(self) -> dict | None:
-        """GET /ml-api/github/token → the full record for the caller's GitHub link.
-
-        ``{id, userId, githubId, username, accessToken, scope, createdAt, updatedAt}``
-        or None when the user has no GitHub link, the token is rejected, or the
-        backend is unreachable. Best-effort: never raises.
+    async def github_token_detail(self) -> tuple[dict | None, str]:
+        """``(record, reason)`` — the GitHub link record, and WHY when there is none.
+
+        The reason exists because collapsing every outcome to ``None`` made a whole
+        class of failure indistinguishable from "this user has no GitHub account".
+        A run then pushes with the box's SSH key instead of the person's token, and —
+        if ``gh`` is not installed — records ``pr_unavailable``, which the compliance
+        gate treats as an explicit non-issue. The ticket completes with no PR of
+        theirs, and nothing anywhere says why. Per-user by construction, which is how
+        one employee ends up with 20 tickets and one PR while everyone else is fine.
+
+        Best-effort: never raises.
         """
         from sdk.config import BE_DEFAULT_URL
 
@@ -945,30 +951,69 @@ class BackendClient:
         try:
             async with httpx.AsyncClient(timeout=15.0) as client:
                 resp = await client.get(url, headers=headers)
-            if resp.status_code >= 400:
-                return None
-            return (resp.json() or {}).get("data") or None
-        except Exception:
-            return None
+        except Exception as exc:  # noqa: BLE001
+            return (None, f"the GitHub token service was unreachable ({type(exc).__name__})")
 
-    async def github_token(self) -> str | None:
-        """GET /ml-api/github/token → the user's GitHub access token (gho_…).
+        if resp.status_code in (401, 403):
+            return (None, (f"the GitHub token request was rejected "
+                           f"({resp.status_code}) — the co_ token may be wrong or "
+                           "the link revoked"))
+        if resp.status_code == 404:
+            return (None, "no GitHub account is linked to this user")
+        if resp.status_code >= 400:
+            return (None, f"the GitHub token service returned {resp.status_code}")
+        try:
+            record = (resp.json() or {}).get("data") or None
+        except Exception:  # noqa: BLE001 — a proxy answering 2xx with HTML
+            return (None, "the GitHub token service returned an unreadable body")
+        if not record:
+            return (None, "no GitHub account is linked to this user")
+        if not (record.get("accessToken") or "").strip():
+            return (None, "the linked GitHub account has no access token stored")
+
+        # The scope is on the record and has never been looked at. A token without
+        # `repo` can often still clone, so the run gets all the way to the push or
+        # the PR call before failing — with the reason buried in a step line.
+        scope = str(record.get("scope") or "")
+        if scope and not any(s in scope for s in ("repo", "public_repo", "write")):
+            return (record, (f"the GitHub token's scope ('{scope}') may not allow "
+                             "pushing or opening PRs"))
+        return (record, "")
 
-        Used by the LOCAL agent to authenticate git/gh for clone/push/PR. The
-        endpoint lives on the ML backend (devopsbot-be), authorised by the same
-        co_ token. Best-effort: returns None on any failure so a run without a
-        connected GitHub account still proceeds (clone/PR steps just won't auth).
+    async def github_token_record(self) -> dict | None:
+        """The GitHub link record, or None. See :meth:`github_token_detail` for why."""
+        record, _reason = await self.github_token_detail()
+        return record
+
+    async def github_token_with_reason(self) -> tuple[str | None, str]:
+        """``(token, reason)`` — the user's GitHub access token, and why when absent.
+
+        Only successes are cached, deliberately: a cached failure would make one bad
+        minute look like an unlinked account for the next half hour.
         """
         import time as _time
 
         now = _time.monotonic()
         cached = _GITHUB_TOKEN_CACHE.get(self._token)
         if cached and now < cached[1]:
-            return cached[0]
-        record = await self.github_token_record()
+            return (cached[0], "")
+        record, reason = await self.github_token_detail()
         token = (record or {}).get("accessToken") or None
         if token:
             _GITHUB_TOKEN_CACHE[self._token] = (token, now + _GITHUB_TOKEN_TTL_S)
+        return (token, reason)
+
+    async def github_token(self) -> str | None:
+        """GET /ml-api/github/token → the user's GitHub access token (gho_…).
+
+        Used by the LOCAL agent to authenticate git/gh for clone/push/PR. The
+        endpoint lives on the ML backend (devopsbot-be), authorised by the same
+        co_ token. Best-effort: returns None on any failure so a run without a
+        connected GitHub account still proceeds (clone/PR steps just won't auth) —
+        callers that report to a human should use :meth:`github_token_with_reason`,
+        because "no token" and "the token call failed" need different fixes.
+        """
+        token, _reason = await self.github_token_with_reason()
         return token
 
     async def ingest_github_prs(self, since: str | None = None) -> dict | None:
@@ -1153,6 +1198,81 @@ class BackendClient:
             logger.warning("client.mark_in_progress error task=%s err=%s", task_id, exc)
             return False
 
+    async def get_task_status(self, task_id: str) -> str | None:
+        """GET {BE}/tasks-ml/{id} → the ticket's CURRENT board status, or None.
+
+        ``None`` means "could not read it", which is deliberately NOT the same as
+        "not Done". The Done safety net in ``handlers.handle_pipeline_approve``
+        forces a status only when it can prove the board has not caught up;
+        guessing on an unreadable ticket would be worse than leaving it alone.
+
+        This method is the one the safety net has always called — and it has never
+        existed. Its absence raised ``AttributeError`` one line before
+        ``set_task_status(task_id, "Done")``, outside that call's ``try``, on every
+        ticket that had just been committed, pushed and PR'd; the auto loop's
+        per-ticket handler then moved the finished ticket to Backlog. So every
+        delivered ticket failed, and only the delivered ones.
+
+        The single-record endpoint is not guaranteed to be served — the backend's
+        own reader documents the same uncertainty and carries the same fallback
+        (``devops-bot-ai/modules/agents_tools/jira/agent.py``, ``get_task``) — so a
+        non-200 or an unparseable body falls back to scanning the list endpoint for
+        this id. Best-effort throughout: never raises.
+        """
+        from sdk.config import BE_DEFAULT_URL
+
+        if not task_id:
+            return None
+        headers = {**self._headers, "accept": "*/*", "developer-name": "null", "product": ""}
+
+        def _status_of(rec: object) -> str | None:
+            if not isinstance(rec, dict):
+                return None
+            val = str(rec.get("status") or "").strip()
+            return val or None
+
+        # 1. Direct single-record read. The body is `{data: {record: {...}}}` or
+        #    `{data: {...}}` depending on the endpoint — accept both.
+        url = f"{BE_DEFAULT_URL.rstrip('/')}/tasks-ml/{task_id}"
+        try:
+            async with httpx.AsyncClient(timeout=20.0) as client:
+                resp = await client.get(url, headers=headers)
+            if resp.status_code < 400:
+                data = (resp.json() or {}).get("data") or {}
+                found = _status_of(data.get("record") if isinstance(data, dict) else None)
+                if found is None and isinstance(data, dict) and data.get("id"):
+                    found = _status_of(data)
+                if found:
+                    return found
+        except Exception as exc:  # noqa: BLE001 — fall through to the list scan
+            logger.warning("client.get_task_status direct failed task=%s err=%s", task_id, exc)
+
+        # 2. Fallback: find the record in the list endpoint. Unfiltered, because
+        #    the point of the read is to learn which status the ticket is in.
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.get(
+                    f"{BE_DEFAULT_URL.rstrip('/')}/tasks-ml",
+                    params={"limit": 10000}, headers=headers,
+                )
+            if resp.status_code >= 400:
+                return None
+            records = ((resp.json() or {}).get("data") or {}).get("records") or []
+            want = str(task_id).strip().upper()
+            for rec in records:
+                if not isinstance(rec, dict):
+                    continue
+                ident = {
+                    str(rec.get("id") or "").strip().upper(),
+                    str(rec.get("jiraIssueKey") or "").strip().upper(),
+                    str(rec.get("jiraKey") or "").strip().upper(),
+                }
+                if want in ident:
+                    return _status_of(rec)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.get_task_status list failed task=%s err=%s", task_id, exc)
+        return None
+
     async def set_task_status(self, task_id: str, status: str) -> bool:
         """PUT {BE}/tasks-ml/{id} status=<status> (best-effort, arbitrary target).
 

{devops_bot_sdk-1.6.38 → devops_bot_sdk-1.6.40}/sdk/git_ops.py

@@ -283,8 +283,16 @@ async def _create_pr_via_api(
             )
         if resp.status_code == 201:
             return resp.json().get("html_url")
-        # 422 = a PR already exists for this head (or validation issue). Try to
-        # surface the existing open PR rather than reporting "no PR".
+        # 422 = a PR already exists for this head (or validation issue). Surfacing
+        # the existing open PR is right when the head really is THIS run's branch —
+        # a re-run pushing more commits to its own branch should report its own PR.
+        #
+        # It was catastrophic when the branch was shared: a constant branch name from
+        # boilerplate instructions or a placeholder-free template made every ticket
+        # push to one branch, and each got handed the first ticket's PR URL, passed
+        # compliance and raised nothing. Branch names are per-ticket now
+        # (`handlers._uniquify_branch`); this check is the second line of defence, so
+        # a PR is only ever claimed when its head ref is the branch we pushed.
         if resp.status_code == 422:
             async with httpx.AsyncClient(timeout=30.0) as c:
                 r2 = await c.get(
@@ -292,7 +300,15 @@ async def _create_pr_via_api(
                     params={"head": f"{owner}:{head}", "state": "open"},
                 )
             if r2.status_code == 200 and r2.json():
-                return r2.json()[0].get("html_url")
+                existing = r2.json()[0]
+                found_head = ((existing.get("head") or {}).get("ref") or "").strip()
+                if found_head and found_head != head:
+                    logger.warning(
+                        "git_ops.pr_head_mismatch asked=%s got=%s — not claiming it",
+                        head, found_head,
+                    )
+                else:
+                    return existing.get("html_url")
         logger.warning(
             "git_ops.pr_api_failed owner=%s repo=%s head=%s status=%s body=%s",
             owner, repo, head, resp.status_code, resp.text[:300],
@@ -302,6 +318,23 @@ async def _create_pr_via_api(
     return None
 
 
+async def has_local_changes(path: str) -> bool:
+    """True when the working tree has staged, unstaged or untracked changes.
+
+    The tool-level counters miss an entire class of real work: `_write_count` only
+    counts Write/Edit/MultiEdit/NotebookEdit, and `files_changed` only events that
+    carry a tool-result filePath. An agent that edits through **Bash** — `sed`,
+    `patch`, `git apply`, a scaffolding CLI — scores zero on both, so no commit,
+    push or PR was ever attempted and the ticket was then failed for "produced 0
+    committed changes". Git is the authority on whether the tree moved.
+    """
+    env = _git_env(None)
+    rc, out, _err = await _run(["git", "status", "--porcelain"], path, env, timeout=60.0)
+    if rc != 0:
+        return False
+    return bool(out.strip())
+
+
 async def finish_pr(
     project_path: str, branch: str, base: str, title: str, body: str,
     github_token: str | None,