devops-bot-sdk 1.4.6__tar.gz → 1.4.11__tar.gz

{devops_bot_sdk-1.4.6 → devops_bot_sdk-1.4.11}/PKG-INFO

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

{devops_bot_sdk-1.4.6 → devops_bot_sdk-1.4.11}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.6 → devops_bot_sdk-1.4.11}/pyproject.toml

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

{devops_bot_sdk-1.4.6 → devops_bot_sdk-1.4.11}/sdk/__init__.py

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

{devops_bot_sdk-1.4.6 → devops_bot_sdk-1.4.11}/sdk/client.py

@@ -36,7 +36,7 @@ from sdk.sse import _check_status, stream_with_reconnect
 
 logger = logging.getLogger(__name__)
 
-SDK_VERSION    = "1.4.6"
+SDK_VERSION    = "1.4.11"
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
 _ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time
@@ -661,6 +661,35 @@ class BackendClient:
         except Exception:
             return None
 
+    async def move_to_backlog(self, task_id: str) -> bool:
+        """PUT {BE}/tasks-ml/{id} status=backlog (best-effort).
+
+        Used when a local run hits the Claude usage limit: the ticket goes BACK to
+        Backlog (not Done) and the loop retries it after the limit resets. Returns
+        True on success; logs and returns False otherwise (e.g. the ML backend
+        rejects the transition for a task with no running timer).
+        """
+        from sdk.config import BE_DEFAULT_URL
+
+        url = f"{BE_DEFAULT_URL.rstrip('/')}/tasks-ml/{task_id}"
+        # multipart form field `status=backlog` — drop any json Content-Type so
+        # httpx sets the multipart boundary itself.
+        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, "backlog")}, headers=headers)
+            if resp.status_code >= 400:
+                logger.warning("client.move_to_backlog failed task=%s status=%s body=%s",
+                               task_id, resp.status_code, resp.text[:200])
+                return False
+            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 notify_whatsapp(
         self,
         task_id: str,

{devops_bot_sdk-1.4.6 → devops_bot_sdk-1.4.11}/sdk/git_ops.py

@@ -143,34 +143,78 @@ async def ensure_repo(
 
 
 async def start_branch(
-    project_path: str, jira_key: str | None, summary: str | None, github_token: str | None,
+    project_path: str,
+    jira_key: str | None,
+    summary: str | None,
+    github_token: str | None,
+    base: str | None = None,
 ) -> dict | None:
-    """Create + check out `feature/<jira_key>-<slug>` off the default branch.
+    """Create + check out `feature/<jira_key>-<slug>` off the resolved base.
+
+    Base resolution (per repo):
+      - `base` given (named in the Jira humanInstructions, possibly per-repo) →
+        branch off the FRESH `origin/<base>` (fetched), falling back to a local
+        `<base>` ref. This is the explicit-override path.
+      - `base` omitted → the repo's CURRENT checked-out branch (the branch the
+        user is actually working on); the feature branch is cut from local HEAD
+        so the user's working state is preserved. If HEAD is detached or already
+        one of OUR `feature/*` branches (a stale checkout from a prior re-run in
+        a shared working tree), fall back to `detect_default_branch` so we never
+        chain a feature branch onto another feature branch.
 
     Returns {"branch", "base"} or None when the path isn't a git repo (e.g. a
-    fresh scratch dir) or the checkout failed.
+    fresh scratch dir) or the checkout failed. The returned `base` is the branch
+    the feature was actually cut from — `finish_pr` uses it as the PR base.
     """
     path = str(Path(project_path).expanduser())
     env = _git_env(github_token)
     if not await _is_git_repo(path, env):
         return None
-    # Fetch first so origin/HEAD and origin/main refs are present/fresh before we
-    # detect the base (avoids resolving the base to the current feature branch).
-    await _run(["git", "fetch", "origin"], path, env, timeout=180.0)
-    base = await detect_default_branch(path, env)
+
     key = slugify(jira_key or "task", max_len=24)
     branch = f"feature/{key}-{slugify(summary)}"
-    if base == branch:
-        # Defensive: never base a PR on the branch we're about to create.
-        base = "main"
-    # Cut the feature branch from the FRESH remote base so it never chains off a
-    # previous ticket's feature branch left checked out in a shared working tree.
-    rc, _, _ = await _run(["git", "checkout", "-B", branch, f"origin/{base}"], path, env)
+    # Fetch so any remote base ref (origin/HEAD, origin/<base>) is present/fresh.
+    await _run(["git", "fetch", "origin"], path, env, timeout=180.0)
+
+    explicit = (base or "").strip()
+    if explicit:
+        # Explicit base from instructions → branch off the FRESH remote tip
+        # (satisfies "pull latest from <base>, then branch"). Fall back to a
+        # local ref of that name, then to a bare branch, if the remote lacks it.
+        await _run(["git", "fetch", "origin", explicit], path, env, timeout=120.0)
+        resolved = "main" if explicit == branch else explicit
+        rc, _, _ = await _run(["git", "checkout", "-B", branch, f"origin/{resolved}"], path, env)
+        if rc != 0:
+            rc, _, _ = await _run(["git", "checkout", "-B", branch, resolved], path, env)
+        if rc != 0:
+            rc, _, _ = await _run(["git", "checkout", "-B", branch], path, env)
+        if rc != 0:
+            return None
+        logger.info("git_ops.branch | %s ← explicit base %s", branch, resolved)
+        return {"branch": branch, "base": resolved}
+
+    # Default: base = the CURRENT checked-out branch (the user's working branch).
+    rc, cur, _ = await _run(["git", "rev-parse", "--abbrev-ref", "HEAD"], path, env)
+    cur = cur.strip() if rc == 0 else ""
+    if cur and cur != "HEAD" and not cur.startswith("feature/"):
+        # Cut from local HEAD — preserve the user's working state, do not pull.
+        rc, _, _ = await _run(["git", "checkout", "-B", branch], path, env)
+        if rc != 0:
+            return None
+        logger.info("git_ops.branch | %s ← current branch %s", branch, cur)
+        return {"branch": branch, "base": cur}
+
+    # HEAD detached or a stale feature/* checkout → fall back to repo default.
+    resolved = await detect_default_branch(path, env)
+    if resolved == branch:
+        resolved = "main"
+    rc, _, _ = await _run(["git", "checkout", "-B", branch, f"origin/{resolved}"], path, env)
     if rc != 0:
         rc, _, _ = await _run(["git", "checkout", "-B", branch], path, env)
     if rc != 0:
         return None
-    return {"branch": branch, "base": base}
+    logger.info("git_ops.branch | %s ← default base %s (HEAD was %r)", branch, resolved, cur or "detached")
+    return {"branch": branch, "base": resolved}
 
 
 async def _remote_owner_repo(path: str, env: dict) -> tuple[str, str] | None:

{devops_bot_sdk-1.4.6 → devops_bot_sdk-1.4.11}/sdk/ipc/handlers.py

@@ -29,6 +29,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import os
 import re
 from typing import Any, AsyncGenerator, Callable
 
@@ -117,6 +118,32 @@ _POLL_INTERVAL_S = 1.5
 _PLAN_DEADLINE_S = 180.0  # planning + approval gate should be quick
 
 
+# Raw task-description budget (chars). The structured plan already distills the
+# task into acceptance criteria + steps, so the raw description is REFERENCE: a
+# very large one is bounded so it cannot bury the operator instructions or the
+# plan (the "follows my instructions sometimes, not others" failure mode). ~6k
+# tokens at ~4 chars/token.
+_DESC_MAX_CHARS = 24_000
+
+
+def _clip_text(text: str, max_chars: int = _DESC_MAX_CHARS) -> str:
+    """Bound a reference string to a char budget, keeping head + tail.
+
+    Pure-python (no tiktoken in the thin SDK). Keeps the start and end and elides
+    the middle with a marker pointing back at the distilled plan.
+    """
+    if not text or len(text) <= max_chars:
+        return text
+    head = max_chars // 2
+    tail = max_chars - head
+    elided = len(text) - head - tail
+    return (
+        f"{text[:head]}\n\n[... {elided} chars elided — the acceptance criteria "
+        f"and implementation steps above are the distilled, authoritative "
+        f"requirements ...]\n\n{text[-tail:]}"
+    )
+
+
 def _build_local_prompt(
     user_input: str | None,
     structured_plan: dict | None,
@@ -125,6 +152,12 @@ def _build_local_prompt(
 ) -> str:
     """Compose the coding prompt for the local claude CLI from the server plan.
 
+    Prompt order matters: a model attends most to the start (and end) of a long
+    prompt, so the MUST-FOLLOW operator instructions LEAD, the distilled plan
+    (acceptance criteria + steps) comes next, and the raw task description is
+    DEMOTED to bounded reference material at the end — never first, never
+    unbounded. This stops a large Jira description from burying the instructions.
+
     `user_input` may be empty when the desktop relied on backend hydration
     (jira_task_id-only run) — the structured plan then carries the task detail.
 
@@ -135,6 +168,7 @@ def _build_local_prompt(
     locally itself.
     """
     parts: list[str] = []
+    # 1. Operator instructions — FIRST, verbatim, authoritative.
     if human_instructions and human_instructions.strip():
         parts.append(
             "=== Operator instructions (Jira humanInstructions) — AUTHORITATIVE ===\n"
@@ -149,8 +183,8 @@ def _build_local_prompt(
             "before changing it.\n\n"
             + human_instructions.strip()
         )
-    if user_input and user_input.strip():
-        parts.append(user_input.strip())
+    # 2. Distilled plan (acceptance criteria + steps) — the compact, actionable
+    #    content the backend planner derived from the full description.
     sp = structured_plan or {}
     criteria = sp.get("acceptance_criteria") or []
     steps = sp.get("task_steps") or []
@@ -163,6 +197,13 @@ def _build_local_prompt(
                 lines.append(f"- {s.get('title', '')}: {s.get('description', '')}".rstrip(": "))
         if lines:
             parts.append("Implementation steps:\n" + "\n".join(lines))
+    # 3. Raw task description — DEMOTED to bounded reference (plan above wins).
+    if user_input and user_input.strip():
+        parts.append(
+            "=== Task description (reference — the operator instructions and plan "
+            "above are authoritative if anything conflicts) ===\n"
+            + _clip_text(user_input.strip())
+        )
     parts.append(
         "Implement all of the above in the current project directory. "
         "Create and edit every file needed for a complete, working result.\n"
@@ -313,6 +354,45 @@ async def _run_local_pipeline(
     await send(_error_envelope(thread_id, RuntimeError("Planning timed out before approval gate.")).model_dump())
 
 
+def _tool_detail(tool_name: str, inp: dict) -> str:
+    """A short, human-readable detail for a tool_use event, for the step timeline.
+
+    Turns a bare "Bash" into the actual command, "Read" into the file, "Grep"
+    into the pattern, etc. — so the progress log says what the agent is doing.
+    """
+    inp = inp or {}
+
+    def _short(s, n=140):
+        return " ".join(str(s).split())[:n]
+
+    if tool_name == "Bash":
+        # Prefer claude's own one-line description, then the command itself.
+        return _short(inp.get("description") or inp.get("command") or "")
+    if tool_name in ("Read", "Write", "Edit", "MultiEdit", "NotebookEdit"):
+        fp = str(inp.get("file_path") or inp.get("notebook_path") or "")
+        return fp.split("/")[-1] if fp else ""
+    if tool_name == "Grep":
+        pat = inp.get("pattern", "")
+        where = inp.get("path") or inp.get("glob") or ""
+        return _short(f"{pat}" + (f" in {where}" if where else ""))
+    if tool_name == "Glob":
+        return _short(inp.get("pattern", ""))
+    if tool_name in ("WebFetch", "WebSearch"):
+        return _short(inp.get("url") or inp.get("query") or "")
+    if tool_name == "Task":
+        return _short(inp.get("description") or inp.get("subagent_type") or "")
+    if tool_name == "TodoWrite":
+        todos = inp.get("todos") or []
+        active = next((t.get("content") for t in todos if t.get("status") == "in_progress"), None)
+        return _short(active) if active else f"{len(todos)} item(s)"
+    # Generic fallback: first useful string field.
+    for k in ("description", "prompt", "query", "command", "path", "url", "file_path"):
+        v = inp.get(k)
+        if isinstance(v, str) and v.strip():
+            return _short(v)
+    return ""
+
+
 async def _code_one_repo(
     client: BackendClient,
     *,
@@ -326,6 +406,7 @@ async def _code_one_repo(
     send: Callable,
     thread_id: str,
     task_id: str,
+    base: str | None = None,
 ) -> dict:
     """Clone-if-needed → branch → run claude → open a PR, for ONE repo.
 
@@ -347,8 +428,8 @@ async def _code_one_repo(
             for c in event.get("message", {}).get("content", []):
                 if c.get("type") == "tool_use":
                     tname = c.get("name", "tool")
-                    fp = (c.get("input", {}) or {}).get("file_path", "")
-                    label = f"Local claude [{name}]: {tname}" + (f" → {fp.split('/')[-1]}" if fp else "")
+                    detail = _tool_detail(tname, c.get("input") or {})
+                    label = f"Local claude [{name}]: {tname}" + (f" → {detail}" if detail else "")
                     await send(Envelope(
                         type="step_update", thread_id=thread_id,
                         data={"status": "running", "current_step": label},
@@ -371,11 +452,13 @@ async def _code_one_repo(
     except Exception:  # noqa: BLE001
         pass
 
-    # 2. feature branch off the repo's real default
+    # 2. feature branch off the resolved base (explicit base from instructions,
+    #    else the repo's current checked-out branch — see git_ops.start_branch).
     branch_info = None
     try:
         branch_info = await git_ops.start_branch(
             repo_path, pending.get("jira_key"), pending.get("summary"), gh_token,
+            base=base,
         )
         if branch_info:
             await send(Envelope(
@@ -574,7 +657,11 @@ async def handle_pipeline_approve(
     # Branch + code + PR each independently; fall back to the single resolved path.
     targets = _extract_repo_targets(pending.get("human_instructions"))
     if not targets:
-        targets = [{"path": pending["project_path"], "url": None}]
+        # No repos named in the instructions → the single resolved project path.
+        # It still honours a global base mentioned in the instructions; None →
+        # start_branch falls back to the repo's current checked-out branch.
+        _, _global_base = _extract_base_branches(pending.get("human_instructions"))
+        targets = [{"path": pending["project_path"], "url": None, "base": _global_base}]
     await send(Envelope(
         type="step_update", thread_id=thread_id,
         data={"current_step": f"{len(targets)} repo(s) to update: "
@@ -587,6 +674,7 @@ async def handle_pipeline_approve(
         try:
             runs.append(await _code_one_repo(
                 client, repo_path=tgt["path"], repo_url=tgt.get("url"),
+                base=tgt.get("base"),
                 pending=pending, prompt=prompt, gh_token=gh_token,
                 agent_mode=agent_mode, approval_dir=approval_dir,
                 send=send, thread_id=thread_id, task_id=task_id,
@@ -624,6 +712,29 @@ async def handle_pipeline_approve(
     if pr_urls:
         agg_result += "\n\nPRs:\n" + "\n".join(pr_urls)
 
+    # ── Claude usage-limit hit: DON'T mark Done. Move the ticket back to Backlog
+    #    and signal the auto-loop to retry this task after the window resets. ──
+    if any(r["result"].get("limit_exceeded") for r in runs):
+        reset_epoch = max((r["result"].get("limit_reset_epoch") or 0) for r in runs) or None
+        moved = await client.move_to_backlog(task_id)
+        await send(Envelope(
+            type="step_update", thread_id=thread_id,
+            data={"task_id": task_id,
+                  "current_step": (("Claude usage limit reached — ticket moved to Backlog"
+                                    if moved else "Claude usage limit reached (Backlog move failed)")
+                                   + "; will retry after the limit resets")},
+        ).model_dump())
+        try:
+            await client.notify_whatsapp(
+                task_id,
+                f"⚠ Task {task_id}: Claude usage limit reached — moved to Backlog; "
+                "will auto-retry after the window resets.",
+                summary="usage limit",
+            )
+        except Exception:  # noqa: BLE001
+            pass
+        return {"status": "limit_exceeded", "reset_epoch": reset_epoch, "task_id": task_id}
+
     # ── Notify on WhatsApp if nothing succeeded ──────────────────────────
     if not ok_any:
         err = "; ".join(str(r["result"].get("error") or "unknown") for r in runs) or "no repos processed"
@@ -1171,13 +1282,113 @@ def _extract_all_paths(text: str | None) -> list[str]:
     return out
 
 
+# Base-branch directives in free-text humanInstructions. Order matters — the
+# more explicit "branch from X" / "base branch: X" forms are tried before the
+# looser "X branch" form so "create a feature branch from main" resolves to
+# `main`, not `feature`. Noise words are filtered out so "the/new/feature/this
+# branch" never resolves to a base.
+import re as _re  # noqa: E402
+
+_BASE_NOISE = {
+    "the", "a", "an", "this", "that", "new", "feature", "features",
+    "your", "same", "current", "default", "its", "please", "create",
+}
+_BASE_DIRECTIVE_RES = [
+    # "branch from/off <base>" — most explicit, tried first. Greedy so a full
+    # name like "release/2.0" is captured, not truncated to "release".
+    _re.compile(r"branch(?:es|ed|ing)?\s+(?:from|off(?:\s+of)?)\s+(?:the\s+)?[\"'`]?([A-Za-z0-9._\-/]+)[\"'`]?(?:\s+branch)?\b", _re.I),
+    # "base branch: <base>" / "base is <base>"
+    _re.compile(r"base(?:\s+branch)?\s*(?:[:=]|\bis\b|\bshould\s+be\b)\s*[\"'`]?([A-Za-z0-9._\-/]+)[\"'`]?\b", _re.I),
+    # "from the <base> branch"
+    _re.compile(r"from\s+(?:the\s+)?[\"'`]?([A-Za-z0-9._\-/]+)[\"'`]?\s+branch\b", _re.I),
+    # loose "<base> branch" (e.g. "main branch") — last, most permissive.
+    _re.compile(r"[\"'`]?([A-Za-z0-9._\-/]+)[\"'`]?\s+branch\b", _re.I),
+]
+
+# Repo-role keywords so a base named alongside "FE"/"backend"/… maps to the
+# matching target even when the path basename doesn't literally contain it.
+_REPO_ROLE_KEYWORDS = (
+    "frontend", "front-end", "fe", "backend", "back-end", "be", "desktop",
+    "mobile", "api", "web", "server", "client",
+)
+
+
+def _find_base_in(text: str | None) -> str | None:
+    """First plausible base-branch name in `text`, or None. Filters noise words."""
+    if not text:
+        return None
+    for rx in _BASE_DIRECTIVE_RES:
+        for m in rx.finditer(text):
+            cand = (m.group(1) or "").strip().strip("./")
+            if cand and cand.lower() not in _BASE_NOISE and not cand.startswith("feature/"):
+                return cand
+    return None
+
+
+def _extract_base_branches(text: str | None) -> tuple[dict[str, str], str | None]:
+    """Parse base-branch directives from humanInstructions.
+
+    Returns (per_repo_bases, global_base):
+      - per_repo_bases: {repo_token: base} where repo_token is a repo name /
+        path basename / role keyword (fe/be/desktop/…) that appeared on the SAME
+        line as a base directive — supports "FE from develop, BE from main".
+      - global_base: a base directive found anywhere (applies to any repo with no
+        more-specific per-repo base). None when no base is mentioned at all.
+    """
+    if not text:
+        return {}, None
+    from pathlib import Path
+
+    def _repo_name(u: str) -> str:
+        n = u.rstrip("/").rsplit("/", 1)[-1]
+        return (n[:-4] if n.lower().endswith(".git") else n).lower()
+
+    per_repo: dict[str, str] = {}
+    for line in text.splitlines():
+        b = _find_base_in(line)
+        if not b:
+            continue
+        tokens: set[str] = set()
+        for u in _GITHUB_URL_RE.findall(line):
+            tokens.add(_repo_name(u))
+        for p in _extract_all_paths(line):
+            tokens.add(Path(p).name.lower())
+        low = line.lower()
+        for kw in _REPO_ROLE_KEYWORDS:
+            if _re.search(rf"\b{_re.escape(kw)}\b", low):
+                tokens.add(kw)
+        for t in tokens:
+            per_repo.setdefault(t, b)
+    return per_repo, _find_base_in(text)
+
+
+def _resolve_base_for(name: str, url: str | None,
+                      per_repo: dict[str, str], global_base: str | None) -> str | None:
+    """Pick the base for one repo: per-repo match (name / url / role keyword) → global."""
+    candidates: list[str] = [name.lower()]
+    if url:
+        n = url.rstrip("/").rsplit("/", 1)[-1]
+        candidates.append((n[:-4] if n.lower().endswith(".git") else n).lower())
+    low = name.lower()
+    for kw in _REPO_ROLE_KEYWORDS:
+        if kw in low:
+            candidates.append(kw)
+    for c in candidates:
+        if c in per_repo:
+            return per_repo[c]
+    return global_base
+
+
 def _extract_repo_targets(text: str | None) -> list[dict]:
-    """All repo work-targets named in `text`: ``[{"path", "url"}]``.
+    """All repo work-targets named in `text`: ``[{"path", "url", "base"}]``.
 
     A single ticket may name several repos (e.g. FE + BE). Each local path is
     paired with a GitHub URL whose repo name matches the path's last segment
     (FE path ↔ FE url, BE path ↔ BE url) so a missing folder can be cloned. A
     path with no matching URL still appears (url=None) — it must already exist.
+    Each target also carries its resolved `base` branch (per-repo override from
+    the instructions, else the global mentioned base, else None → the SDK uses
+    the repo's current checked-out branch).
     """
     if not text:
         return []
@@ -1187,10 +1398,17 @@ def _extract_repo_targets(text: str | None) -> list[dict]:
         n = u.rstrip("/").rsplit("/", 1)[-1]
         return (n[:-4] if n.lower().endswith(".git") else n).lower()
 
+    per_repo_bases, global_base = _extract_base_branches(text)
     by_name = {_repo_name(u): u for u in _GITHUB_URL_RE.findall(text)}
     targets: list[dict] = []
     for p in _extract_all_paths(text):
-        targets.append({"path": p, "url": by_name.get(Path(p).name.lower())})
+        name = Path(p).name
+        url = by_name.get(name.lower())
+        targets.append({
+            "path": p,
+            "url": url,
+            "base": _resolve_base_for(name, url, per_repo_bases, global_base),
+        })
     return targets
 
 
@@ -1235,6 +1453,40 @@ _APPROVAL_POLL_TIMEOUT_S = 1200.0
 _MAX_CONTEXT_RESUMES = 3
 # Max mid-run crucial-decision approval gates per ticket (safety bound).
 _MAX_CRUCIAL_GATES = 10
+# Max times a ticket is retried after hitting the Claude usage limit.
+_MAX_LIMIT_RETRIES = 3
+# Cap on how long we'll sleep waiting for a usage-limit window to reset.
+_LIMIT_MAX_WAIT_S = 6 * 60 * 60.0
+# Fallback wait when the limit message carries no reset time.
+_LIMIT_FALLBACK_WAIT_S = float(os.getenv("AGENTOS_LIMIT_DEFAULT_WAIT_S", "") or 3600.0)
+
+
+def _limit_wait_seconds(reset_epoch: int | None) -> float:
+    """Seconds to wait before retrying after a usage-limit hit.
+
+    Uses the reset timestamp the limit message carried (+60s buffer); otherwise a
+    fallback. Always capped at _LIMIT_MAX_WAIT_S so a bad timestamp can't park the
+    loop for days.
+    """
+    import time as _t
+    if reset_epoch:
+        wait = max(0.0, float(reset_epoch) - _t.time()) + 60.0
+    else:
+        wait = _LIMIT_FALLBACK_WAIT_S
+    return min(wait, _LIMIT_MAX_WAIT_S)
+
+
+async def _cooperative_sleep(seconds: float, should_stop: Callable[[], bool] | None) -> bool:
+    """Sleep `seconds`, checking should_stop periodically. Returns False if a stop
+    was requested mid-sleep (so the caller can pause cleanly), else True."""
+    waited = 0.0
+    while waited < seconds:
+        if should_stop is not None and should_stop():
+            return False
+        chunk = min(30.0, seconds - waited)
+        await asyncio.sleep(chunk)
+        waited += chunk
+    return True
 
 
 async def _poll_approval(
@@ -1364,52 +1616,86 @@ async def handle_orchestrate_auto_local_run(
             # Per-ticket isolation: a failure here (network, git, a raising
             # repo) must NOT abort the remaining tickets — log it and move on.
             try:
-                # Phase 1 — server plans + gates. NO local code/bash runs yet.
-                await _run_local_pipeline(client, task_payload, send)
-                session_id = next(
-                    (sid for sid, p in _PENDING_LOCAL.items() if p.get("task_id") == tid),
-                    None,
-                )
-                if not session_id:
-                    # Planning never reached the approval gate for this task — skip it.
-                    await send(Envelope(
-                        type="step_update", thread_id=thread_id,
-                        data={"current_step": f"{jira_key}: skipped (no approval gate reached)"},
-                    ).model_dump())
-                    continue
+                # Retry the ticket if a run hits the Claude usage limit:
+                # handle_pipeline_approve moves it to Backlog and signals here; we
+                # wait for the window to reset and re-run — up to _MAX_LIMIT_RETRIES.
+                attempt = 0
+                while True:
+                    attempt += 1
+                    # Phase 1 — server plans + gates. NO local code/bash runs yet.
+                    await _run_local_pipeline(client, task_payload, send)
+                    session_id = next(
+                        (sid for sid, p in _PENDING_LOCAL.items() if p.get("task_id") == tid),
+                        None,
+                    )
+                    if not session_id:
+                        # Planning never reached the approval gate — skip this ticket.
+                        await send(Envelope(
+                            type="step_update", thread_id=thread_id,
+                            data={"current_step": f"{jira_key}: skipped (no approval gate reached)"},
+                        ).model_dump())
+                        break
 
-                # First-approval gate: when agentMode is ON, WAIT for the human's
-                # WhatsApp approval before ANY local code/bash. When OFF, proceed.
-                if agent_mode:
-                    await send(Envelope(
-                        type=Envelope.TYPE_AWAITING_APPROVAL, thread_id=thread_id,
-                        data={"jira_key": jira_key, "session_id": session_id, "task_id": tid,
-                              "current_step": f"{jira_key}: awaiting approval"},
-                    ).model_dump())
-                    decision = await _poll_approval(client, tid, should_stop)
-                    if decision == "stopped":
-                        _PENDING_LOCAL.pop(session_id, None)
+                    # First-approval gate: when agentMode is ON, WAIT for the human's
+                    # WhatsApp approval before ANY local code/bash. When OFF, proceed.
+                    if agent_mode:
                         await send(Envelope(
-                            type=Envelope.TYPE_DONE, thread_id=thread_id,
-                            data={"mode": "orchestrate-auto-local", "status": "paused",
-                                  "processed": processed, "task_count": total},
+                            type=Envelope.TYPE_AWAITING_APPROVAL, thread_id=thread_id,
+                            data={"jira_key": jira_key, "session_id": session_id, "task_id": tid,
+                                  "current_step": f"{jira_key}: awaiting approval"},
                         ).model_dump())
-                        return
-                    if decision != "approved":
-                        _PENDING_LOCAL.pop(session_id, None)
+                        decision = await _poll_approval(client, tid, should_stop)
+                        if decision == "stopped":
+                            _PENDING_LOCAL.pop(session_id, None)
+                            await send(Envelope(
+                                type=Envelope.TYPE_DONE, thread_id=thread_id,
+                                data={"mode": "orchestrate-auto-local", "status": "paused",
+                                      "processed": processed, "task_count": total},
+                            ).model_dump())
+                            return
+                        if decision != "approved":
+                            _PENDING_LOCAL.pop(session_id, None)
+                            await send(Envelope(
+                                type="step_update", thread_id=thread_id,
+                                data={"current_step": f"{jira_key}: {decision} — skipped"},
+                            ).model_dump())
+                            break
+
+                    # Phase 2 — run the user's local `claude`, report back.
+                    outcome = await handle_pipeline_approve(
+                        client,
+                        {"session_id": session_id, "decision": "approved", "thread_id": thread_id},
+                        send,
+                    )
+
+                    # Usage limit → ticket is now in Backlog. Wait for reset + retry.
+                    if isinstance(outcome, dict) and outcome.get("status") == "limit_exceeded":
+                        if attempt <= _MAX_LIMIT_RETRIES:
+                            wait_s = _limit_wait_seconds(outcome.get("reset_epoch"))
+                            await send(Envelope(
+                                type="step_update", thread_id=thread_id,
+                                data={"current_step": f"{jira_key}: Claude usage limit — waiting "
+                                                      f"{round(wait_s / 60)}m for reset, then retry "
+                                                      f"({attempt}/{_MAX_LIMIT_RETRIES})"},
+                            ).model_dump())
+                            if not await _cooperative_sleep(wait_s, should_stop):
+                                await send(Envelope(
+                                    type=Envelope.TYPE_DONE, thread_id=thread_id,
+                                    data={"mode": "orchestrate-auto-local", "status": "paused",
+                                          "processed": processed, "task_count": total},
+                                ).model_dump())
+                                return
+                            continue  # re-run this ticket from phase 1
+                        # Out of retries — leave it in Backlog for a later run.
                         await send(Envelope(
                             type="step_update", thread_id=thread_id,
-                            data={"current_step": f"{jira_key}: {decision} — skipped"},
+                            data={"current_step": f"{jira_key}: usage limit — max retries reached, "
+                                                  f"left in Backlog"},
                         ).model_dump())
-                        continue
+                        break
 
-                # Phase 2 — run the user's local `claude`, report back.
-                await handle_pipeline_approve(
-                    client,
-                    {"session_id": session_id, "decision": "approved", "thread_id": thread_id},
-                    send,
-                )
-                processed += 1
+                    processed += 1
+                    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 send(Envelope(

{devops_bot_sdk-1.4.6 → devops_bot_sdk-1.4.11}/sdk/local_exec.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 import asyncio
 import json
 import os
+import re
 import shutil
 from pathlib import Path
 from typing import Any, Awaitable, Callable
@@ -29,8 +30,21 @@ from typing import Any, Awaitable, Callable
 # user's machine, not the server.
 DEFAULT_ALLOWED_TOOLS = ["Read", "Write", "Edit", "Glob", "Grep", "Bash"]
 
-# Hard ceiling so a runaway agent can't hang the sidecar forever.
-_DEFAULT_TIMEOUT_S = 1800.0
+# Run limits. The OLD design capped TOTAL runtime at 30 min, which killed long
+# but healthy runs (big builds, many steps) mid-work. Instead we use an IDLE
+# timeout — abort only if claude emits NOTHING for this long (truly stuck) — plus
+# a generous absolute backstop so a runaway can't hang forever. Both env-tunable.
+def _f(env: str, default: float) -> float:
+    try:
+        return float(os.getenv(env, "") or default)
+    except ValueError:
+        return default
+
+
+# No output for this long → the run is stuck → abort.
+_IDLE_TIMEOUT_S = _f("AGENTOS_LOCAL_IDLE_TIMEOUT_S", 900.0)      # 15 min of silence
+# Absolute backstop on total wall-clock regardless of activity.
+_DEFAULT_TIMEOUT_S = _f("AGENTOS_LOCAL_MAX_S", 4 * 60 * 60.0)    # 4 h
 
 # StreamReader buffer for the claude CLI's stdout. `--output-format stream-json`
 # emits one JSON object per line, and a single event can embed a whole file's
@@ -46,6 +60,37 @@ _CONTEXT_MARKERS = (
     "token limit", "prompt is too long", "exceeds the maximum", "context_length_exceeded",
 )
 
+# Markers that indicate the Claude USAGE/RATE limit (the N-hour window) was hit —
+# distinct from a context overflow. The run didn't fail on the task; the account
+# is throttled until the window resets.
+_LIMIT_MARKERS = (
+    "usage limit reached", "usage limit", "rate limit", "rate_limit",
+    "too many requests", "limit will reset", "limit reached", "overloaded_error",
+    "resets at", "429",
+)
+# A unix-seconds reset timestamp claude sometimes appends (e.g. "...reached|1719500400").
+_RESET_EPOCH_RE = re.compile(r"\b(1[6-9]\d{8}|20\d{8})\b")
+# Fallback wait when the limit message carries no reset time (env-tunable).
+_LIMIT_DEFAULT_WAIT_S = _f("AGENTOS_LIMIT_DEFAULT_WAIT_S", 60 * 60.0)   # 1 h
+
+
+def _is_limit(text: str | None) -> bool:
+    low = (text or "").lower()
+    return any(m in low for m in _LIMIT_MARKERS)
+
+
+def _parse_reset_epoch(text: str | None) -> int | None:
+    """A unix-seconds reset time embedded in a limit message, if present."""
+    if not text:
+        return None
+    m = _RESET_EPOCH_RE.search(text)
+    if m:
+        try:
+            return int(m.group(1))
+        except ValueError:
+            return None
+    return None
+
 
 def _ctx_exceeded(text: str | None) -> bool:
     low = (text or "").lower()
@@ -74,6 +119,7 @@ async def run_claude_local(
     github_token: str | None = None,
     resume_session_id: str | None = None,
     approval_dir: str | None = None,
+    idle_timeout: float = _IDLE_TIMEOUT_S,
 ) -> dict[str, Any]:
     """Run the local `claude` CLI non-interactively against ``project_path``.
 
@@ -168,13 +214,22 @@ async def run_claude_local(
     result_event: dict | None = None
     files_changed: list[str] = []
     session_id: str | None = resume_session_id
+    import time as _time
+    started = _time.monotonic()
+    stall = {"timed_out": False, "reason": ""}
 
     async def _drain_stdout() -> None:
         nonlocal result_event, session_id
         assert proc.stdout is not None
         while True:
             try:
-                raw = await proc.stdout.readline()
+                # IDLE timeout: abort only if claude produces NO output for this
+                # long (genuinely stuck), so long-but-active runs aren't killed.
+                raw = await asyncio.wait_for(proc.stdout.readline(), timeout=idle_timeout)
+            except asyncio.TimeoutError:
+                stall["timed_out"] = True
+                stall["reason"] = f"no output for {idle_timeout:.0f}s (stuck)"
+                return
             except ValueError:
                 # Line exceeded even _STREAM_LIMIT_BYTES. readline() has already
                 # advanced past the oversized chunk, so we can safely skip this
@@ -182,6 +237,11 @@ async def run_claude_local(
                 continue
             if not raw:
                 break
+            # Absolute backstop on total wall-clock (checked as events arrive).
+            if _time.monotonic() - started > timeout:
+                stall["timed_out"] = True
+                stall["reason"] = f"exceeded absolute cap {timeout:.0f}s"
+                return
             line = raw.decode("utf-8", errors="replace").strip()
             if not line:
                 continue
@@ -212,16 +272,20 @@ async def run_claude_local(
                 except Exception:
                     pass  # progress forwarding is best-effort
 
-    try:
-        await asyncio.wait_for(_drain_stdout(), timeout=timeout)
-        await asyncio.wait_for(proc.wait(), timeout=30.0)
-    except asyncio.TimeoutError:
+    await _drain_stdout()
+    if not stall["timed_out"]:
+        try:
+            await asyncio.wait_for(proc.wait(), timeout=30.0)
+        except asyncio.TimeoutError:
+            stall["timed_out"] = True
+            stall["reason"] = "process did not exit after the stream closed"
+    if stall["timed_out"]:
         try:
             proc.kill()
         except ProcessLookupError:
             pass
         return {
-            "ok": False, "result": "", "error": f"claude CLI timed out after {timeout:.0f}s",
+            "ok": False, "result": "", "error": f"claude CLI timed out — {stall['reason']}",
             "input_tokens": 0, "output_tokens": 0, "total_tokens": 0,
             "cost_usd": 0.0, "files_changed": files_changed,
             "session_id": session_id, "context_exceeded": False,
@@ -235,17 +299,31 @@ async def run_claude_local(
             "input_tokens": 0, "output_tokens": 0, "total_tokens": 0,
             "cost_usd": 0.0, "files_changed": files_changed,
             "session_id": session_id, "context_exceeded": _ctx_exceeded(err),
+            "limit_exceeded": _is_limit(err), "limit_reset_epoch": _parse_reset_epoch(err),
         }
 
     usage = result_event.get("usage") or {}
     in_tok = int(usage.get("input_tokens", 0) or 0)
     out_tok = int(usage.get("output_tokens", 0) or 0)
     is_error = bool(result_event.get("is_error", False))
+    result_text = str(result_event.get("result", ""))
+    subtype = str(result_event.get("subtype", ""))
+
+    # Claude USAGE/RATE limit: detected from the result/subtype even when the CLI
+    # didn't flag is_error — so a limit-truncated run is NOT treated as success
+    # (which would wrongly mark the ticket Done).
+    limit_hit = _is_limit(result_text) or "limit" in subtype.lower()
+    reset_epoch = _parse_reset_epoch(result_text)
+
+    err_text = None
+    if is_error:
+        err_text = result_text or "claude reported an error"
+    elif limit_hit:
+        err_text = result_text or "claude usage limit reached"
 
-    err_text = None if not is_error else str(result_event.get("result", "claude reported an error"))
     return {
-        "ok": not is_error,
-        "result": str(result_event.get("result", "")),
+        "ok": (not is_error) and (not limit_hit),
+        "result": result_text,
         "input_tokens": in_tok,
         "output_tokens": out_tok,
         "total_tokens": in_tok + out_tok,
@@ -254,4 +332,6 @@ async def run_claude_local(
         "error": err_text,
         "session_id": session_id,
         "context_exceeded": is_error and _ctx_exceeded(err_text),
+        "limit_exceeded": limit_hit,
+        "limit_reset_epoch": reset_epoch,
     }