devops-bot-sdk 1.4.62__tar.gz → 1.4.65__tar.gz

{devops_bot_sdk-1.4.62 → devops_bot_sdk-1.4.65}/PKG-INFO

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

{devops_bot_sdk-1.4.62 → devops_bot_sdk-1.4.65}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.62 → devops_bot_sdk-1.4.65}/pyproject.toml

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

{devops_bot_sdk-1.4.62 → devops_bot_sdk-1.4.65}/sdk/__init__.py

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

{devops_bot_sdk-1.4.62 → devops_bot_sdk-1.4.65}/sdk/client.py

@@ -58,7 +58,7 @@ def _notify_status(task_id: str, status: str) -> None:
             pass
 
 
-SDK_VERSION    = "1.4.62"
+SDK_VERSION    = "1.4.65"
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
 _ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time
@@ -821,7 +821,7 @@ class BackendClient:
         # field like `modelUsed` can repeat.
         files = [(k, (None, str(v))) for k, v in fields.items() if v is not None]
         for m in (model_used or []):
-            files.append(("modelUsed", (None, str(m))))
+            files.append(("modelUsed[]", (None, str(m))))  # [] → backend parses as array
         try:
             async with httpx.AsyncClient(timeout=30.0) as client:
                 resp = await client.put(url, files=files, headers=headers)
@@ -850,7 +850,7 @@ class BackendClient:
         headers.update({"accept": "*/*", "developer-name": "null", "product": ""})
         files = [(k, (None, str(v))) for k, v in fields.items() if v is not None]
         for m in (model_used or []):
-            files.append(("modelUsed", (None, str(m))))
+            files.append(("modelUsed[]", (None, str(m))))  # [] → backend parses as array
         try:
             async with httpx.AsyncClient(timeout=30.0) as client:
                 resp = await client.post(url, files=files, headers=headers)

{devops_bot_sdk-1.4.62 → devops_bot_sdk-1.4.65}/sdk/ipc/handlers.py

@@ -371,6 +371,50 @@ def _parse_scope(recon_text: str | None) -> str:
     return "in"
 
 
+# Heartbeat cadence for long, quiet local runs (PRD generation, validation) so the
+# log shows liveness even when the agent is generating text with no tool calls.
+_HEARTBEAT_S = float(os.getenv("AGENTOS_HEARTBEAT_S", "") or 20.0)
+
+
+async def _run_with_heartbeat(coro, *, send: Callable, thread_id: str, label: str,
+                              name: str | None = None, interval: float = _HEARTBEAT_S):
+    """Await `coro` while emitting a periodic 'still working (Ns)' step_update, so a
+    long-but-quiet local run (e.g. PRD generation) never looks frozen in the log."""
+    import time as _t
+
+    prefix = f"[{name}] " if name else ""
+    stop = asyncio.Event()
+    started = _t.monotonic()
+
+    async def _beat() -> None:
+        try:
+            while not stop.is_set():
+                try:
+                    await asyncio.wait_for(stop.wait(), timeout=interval)
+                    return
+                except asyncio.TimeoutError:
+                    pass
+                await send(Envelope(
+                    type="step_update", thread_id=thread_id,
+                    data={"status": "running",
+                          "current_step": f"{prefix}{label} … still working "
+                                          f"({int(_t.monotonic() - started)}s)"},
+                ).model_dump())
+        except asyncio.CancelledError:
+            return
+
+    beat = asyncio.create_task(_beat())
+    try:
+        return await coro
+    finally:
+        stop.set()
+        beat.cancel()
+        try:
+            await beat
+        except Exception:  # noqa: BLE001
+            pass
+
+
 # ── Epic decomposition ────────────────────────────────────────────────────
 # An EPIC is not coded directly. It is analysed (grounded in the codebase when a
 # project path exists) into a detailed user-story description + an implementation
@@ -624,9 +668,14 @@ async def _validate_ticket_or_reject(
     we never block a ticket on our own infrastructure error."""
     from sdk import local_exec
 
+    from pathlib import Path
+
     tid = str(task.get("id", ""))
     jira_key = task.get("jiraIssueKey") or task.get("jiraKey", "") or kind.upper()
-    project_path = _resolve_local_project_path(task, payload)
+    # Validation is a pure text judgment — run it in a guaranteed-writable scratch
+    # dir, never the resolved project path (which may not exist yet or be unwritable,
+    # e.g. a code-reference like /components). This decouples the gate from the repo.
+    scratch = str(Path.home() / ".agentos" / "validate")
 
     await send(Envelope(
         type="step_update", thread_id=thread_id,
@@ -634,11 +683,14 @@ async def _validate_ticket_or_reject(
               "current_step": f"{kind.title()} {jira_key}: validating ticket against the standard"},
     ).model_dump())
 
-    res = await local_exec.run_claude_local(
-        _build_validation_prompt(kind, jira_key, task.get("summary", "") or "",
-                                 task.get("description"), task.get("humanInstructions")),
-        project_path, allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only judgment
-        github_token=await client.github_token(),
+    res = await _run_with_heartbeat(
+        local_exec.run_claude_local(
+            _build_validation_prompt(kind, jira_key, task.get("summary", "") or "",
+                                     task.get("description"), task.get("humanInstructions")),
+            scratch, allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only judgment, scratch dir
+            github_token=await client.github_token(),
+        ),
+        send=send, thread_id=thread_id, label=f"{kind.title()} {jira_key}: validating",
     )
     if not res.get("ok"):
         await client.log_activity(
@@ -1237,13 +1289,16 @@ async def _code_one_repo(
             data={"status": "running",
                   "current_step": f"[{name}] Recon — exploring the repo to ground the plan"},
         ).model_dump())
-        recon = await local_exec.run_claude_local(
-            _build_recon_prompt(
-                name, pending["user_input"], pending.get("structured_plan"),
-                pending.get("human_instructions"),
+        recon = await _run_with_heartbeat(
+            local_exec.run_claude_local(
+                _build_recon_prompt(
+                    name, pending["user_input"], pending.get("structured_plan"),
+                    pending.get("human_instructions"),
+                ),
+                repo_path, on_event=_on_event, github_token=gh_token,
+                allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only: no Write/Edit/Bash
             ),
-            repo_path, on_event=_on_event, github_token=gh_token,
-            allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only: no Write/Edit/Bash
+            send=send, thread_id=thread_id, label="Exploring the repo (recon)", name=name,
         )
         recon_session = recon.get("session_id")
         # A usage-limit hit during recon must be surfaced so the loop waits/retries
@@ -1343,9 +1398,13 @@ async def _code_one_repo(
                 "code you found. Output ONLY the PRD as Markdown, following this format "
                 "exactly:\n\n" + _PRD_FORMAT
             )
-        prd_res = await local_exec.run_claude_local(
-            instruction, repo_path, allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only
-            github_token=gh_token, resume_session_id=recon_session,
+        prd_res = await _run_with_heartbeat(
+            local_exec.run_claude_local(
+                instruction, repo_path, on_event=_on_event,  # stream tool activity
+                allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only
+                github_token=gh_token, resume_session_id=recon_session,
+            ),
+            send=send, thread_id=thread_id, label="Working on the PRD", name=name,
         )
         recon_session = prd_res.get("session_id") or recon_session
         prd = (prd_res.get("result") or "").strip() if prd_res.get("ok") else ""
@@ -2588,6 +2647,16 @@ def _extract_repo_targets(text: str | None) -> list[dict]:
     for p in _extract_all_paths(text):
         name = Path(p).name
         url = by_name.get(name.lower())
+        # Ignore bare code-reference paths mentioned in the instructions (e.g.
+        # "use shared components in `/components`") that are neither a real repo
+        # (paired with a GitHub URL) nor an existing local directory. Without this
+        # a path like /components gets picked as the work dir → Permission denied.
+        if not url:
+            try:
+                if not Path(p).expanduser().is_dir():
+                    continue
+            except OSError:
+                continue
         targets.append({
             "path": p,
             "url": url,
@@ -2626,13 +2695,25 @@ def _resolve_local_project_path(task: dict, payload: dict) -> str:
     if overrides.get(tid):
         return str(Path(overrides[tid]).expanduser())
 
-    # PRIMARY — honour the location the human wrote in the Jira task.
+    # PRIMARY — honour the location the human wrote in the Jira task. Prefer a REAL
+    # repo (a path paired with a GitHub URL), then any surviving repo target
+    # (existing local dir), then a bare path that actually exists — never a
+    # code-reference path like `/components` that doesn't exist on disk.
     for field in ("humanInstructions", "description"):
-        found = _extract_path_from_text(task.get(field))
-        if found:
+        text = task.get(field)
+        if not text:
+            continue
+        targets = _extract_repo_targets(text)  # spurious/non-existent paths filtered out
+        with_url = next((t["path"] for t in targets if t.get("url")), None)
+        if with_url:
+            return with_url
+        if targets:
+            return targets[0]["path"]
+        found = _extract_path_from_text(text)
+        if found and Path(found).expanduser().exists():
             return found
 
-    # FALLBACK — only when no location was instructed anywhere.
+    # FALLBACK — no usable location instructed anywhere.
     root = payload.get("workspace_root") or str(Path.home() / "AgentOS")
     key = (
         task.get("projectKey")