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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.62
+Version: 1.4.66
 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.66}/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.66
 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.66}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devops-bot-sdk"
-version = "1.4.62"
+version = "1.4.66"
 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.66}/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.66
 
 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.66"
 __author__  = "AgentOS"
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.4.62 → devops_bot_sdk-1.4.66}/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.66"
 _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.66}/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
@@ -572,30 +616,42 @@ def _build_validation_prompt(kind: str, jira_key: str, summary: str,
         "Description:\n" + (_clip_text(description.strip()) if description and description.strip() else "(none provided)"),
         "Human Instructions:\n" + (human.strip() if human and human.strip() else "(none provided)"),
     ]
+    is_epic = kind == "epic"
     parts.append(
-        "Judge the ticket in the context of what it ACTUALLY asks for — it may be "
-        "software, documentation, analysis, Finance, HR or operations work. Do NOT "
-        "impose software requirements on a non-software ticket.\n\n"
+        "Judge the ticket for what it ACTUALLY asks for — software, documentation, "
+        "analysis, Finance, HR or operations. Do NOT impose requirements the ticket "
+        "does not need.\n\n"
         "A VALID ticket MUST have:\n"
         "- A clear, unambiguous goal and scope (no hand-waving).\n"
-        "- A clearly-defined deliverable or outcome, and — when a location matters — "
-        "WHERE to produce it (a folder path, a repository, or a document).\n"
-        "- Observable, testable acceptance criteria (or an equally concrete definition of done).\n"
-        "- ONLY IF the work requires CODE CHANGES to a software project: the target "
-        "repository link(s) and/or file path(s), the branch/PR convention, and "
-        "build/run/test steps. Do NOT demand these for documentation, content, analysis "
-        "or other non-code deliverables.\n"
-        + ("- Enough concrete detail to decompose into independent user stories.\n"
-           if kind == "epic" else
-           "- A clear 'As a <role>, I want <capability>, so that <benefit>' intent plus "
-           "testable acceptance criteria.\n")
+        "- A clearly-defined deliverable/outcome (and where to produce it when a "
+        "location matters).\n"
+        "- Observable acceptance criteria (or an equally concrete definition of done).\n"
+        + (
+            # EPIC: a decomposition container — NEVER require code-execution details.
+            "- Enough substance to DECOMPOSE into user stories.\n"
+            "IMPORTANT: this is an EPIC — a high-level container the system decomposes "
+            "into user stories. Do NOT require a repository URL, file paths, branch/PR "
+            "convention, or build/run/test commands at the epic level; those are "
+            "established LATER at the story/task stage, never in the epic. Even when the "
+            "epic describes software features, judge it ONLY on goal, scope, user "
+            "stories and epic-level acceptance criteria. NEVER reject an epic for missing "
+            "repository, branch, PR, build, or test details.\n"
+            if is_epic else
+            # STORY: repo details help but the PRD/coding stage grounds them.
+            "- A clear 'As a <role>, I want <capability>, so that <benefit>' intent plus "
+            "testable acceptance criteria.\n"
+            "For a code story, a target repo/path is helpful but NOT mandatory here — the "
+            "PRD/coding stage grounds it against the codebase. Do NOT reject solely for a "
+            "missing branch/PR convention or build/test steps.\n"
+        )
         + "- Any THIRD-PARTY INTEGRATION or human-effort dependency the work GENUINELY "
-        "needs (API keys, OAuth credentials, external accounts, secrets, manual "
-        "provisioning, DNS, billing) MUST be named WITH who provides it; if such a "
-        "REQUIRED dependency is undefined, REJECT.\n\n"
-        "A ticket that clearly states its deliverable and where to produce it is VALID "
-        "even without repository/branch details. Reject only for genuinely missing or "
-        "ambiguous information — not for absent software details the task does not need.\n\n"
+        "needs (API keys, OAuth credentials, external accounts, secrets, provisioning) "
+        "MUST be named WITH who provides it; if a REQUIRED dependency is undefined, REJECT.\n\n"
+        "Unrendered template placeholders — an EMPTY `{{...}}` or `<...>` with no real "
+        "content — are a valid reason to reject. But if a section contains real content "
+        "merely wrapped in stray markers, treat it as PRESENT, not missing.\n"
+        "Reject only for genuinely missing or ambiguous information — not for absent "
+        "execution details the ticket does not need at this stage.\n\n"
         "Output ONLY a fenced ```json block, nothing else:\n"
         "{\n"
         '  "valid": true or false,\n'
@@ -624,9 +680,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 +695,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 +1301,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 +1410,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 +2659,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 +2707,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")