devops-bot-sdk 1.6.76__tar.gz → 1.6.84__tar.gz

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.84}/PKG-INFO

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

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.84}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.84}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ devops_bot_sdk.egg-info/top_level.txt
 sdk/__init__.py
 sdk/agentd.py
 sdk/browser_profile.py
+sdk/claude_usage.py
 sdk/cli.py
 sdk/client.py
 sdk/config.py
@@ -17,6 +18,7 @@ sdk/custom_agents.py
 sdk/departments.py
 sdk/estimator.py
 sdk/exceptions.py
+sdk/fallback_handoff.py
 sdk/firewall.py
 sdk/formats.py
 sdk/git_ops.py
@@ -24,6 +26,8 @@ sdk/github_fetch.py
 sdk/github_ingest.py
 sdk/graph_recon.py
 sdk/graphify.py
+sdk/helpdesk.py
+sdk/helpdesk_kb.md
 sdk/intake.py
 sdk/journal.py
 sdk/local_exec.py
@@ -161,13 +165,16 @@ tests/test_agent_workspace_settings.py
 tests/test_agents_connectors_builder.py
 tests/test_allowed_tools_config.py
 tests/test_auto_agent_dispatch.py
+tests/test_auto_ticket_queue.py
 tests/test_browser_profile.py
 tests/test_cheap_tier.py
+tests/test_claude_usage_gate.py
 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_create_safe_retry.py
 tests/test_departments.py
 tests/test_done_transition.py
 tests/test_epic_decompose_run.py
@@ -175,6 +182,7 @@ tests/test_epic_inherited_agent_id.py
 tests/test_epic_session_isolation.py
 tests/test_estimator.py
 tests/test_fallback_cli.py
+tests/test_fallback_cli_upgrade.py
 tests/test_firewall_open_on_update.py
 tests/test_formats.py
 tests/test_git_action.py
@@ -184,12 +192,15 @@ tests/test_graph_recon.py
 tests/test_graphify_build.py
 tests/test_graphify_hook_install.py
 tests/test_health.py
+tests/test_helpdesk.py
 tests/test_intake_job_outcome.py
 tests/test_intake_plan_review.py
 tests/test_journal.py
+tests/test_limit_fallback_handoff.py
 tests/test_local_exec_provider.py
 tests/test_mcp_route_contract.py
 tests/test_memory_guard.py
+tests/test_panel_ticket_schedules.py
 tests/test_phase_timer.py
 tests/test_plan_new_command.py
 tests/test_plan_run_activity.py
@@ -218,6 +229,7 @@ tests/test_task_file_format_doc.py
 tests/test_ticket_cli.py
 tests/test_ticket_fields.py
 tests/test_ticket_run_resolve_by_id.py
+tests/test_ticket_schedule_and_agent.py
 tests/test_ticket_speed_fixes.py
 tests/test_tier_flag_parity.py
 tests/test_ui_gate.py
@@ -231,5 +243,6 @@ tests/test_vps_health.py
 tests/test_vps_only_reporting.py
 tests/test_windows_loop_identity.py
 tests/test_windows_panel_task.py
+tests/test_windows_stop_and_pidfile.py
 tests/test_windows_task_paths.py
 tests/test_write_hook.py

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.84}/pyproject.toml

@@ -68,7 +68,7 @@ where = ["."]
 include = ["sdk*"]
 
 [tool.setuptools.package-data]
-sdk = ["py.typed", "ui/static/*"]
+sdk = ["py.typed", "ui/static/*", "helpdesk_kb.md"]
 
 [tool.ruff]
 line-length   = 100

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.84}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.6.76
+Version: 1.6.84
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -34,7 +34,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.6.76"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.84"   # 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.76 → devops_bot_sdk-1.6.84}/sdk/agentd.py

@@ -176,13 +176,11 @@ def _read_pid() -> int | None:
 
 
 def _pid_alive(pid: int) -> bool:
-    try:
-        os.kill(pid, 0)  # signal 0 → existence/permission check, no actual signal
-    except ProcessLookupError:
-        return False
-    except PermissionError:
-        return True  # exists but owned by another user
-    return True
+    """Delegates to run_auto's probe — NOT ``os.kill(pid, 0)``, which on Windows is
+    ``TerminateProcess`` (it kills a live agentd) and raises a bare OSError
+    (WinError 87) for a dead pid, crashing `status`/`start` on a stale pidfile."""
+    from sdk import run_auto
+    return run_auto._pid_alive(pid)
 
 
 def _daemon_running() -> int | None:

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.84}/sdk/agents/schedules.py

@@ -49,9 +49,10 @@ MAX_CONSECUTIVE_FAILURES = 3
 
 _SLUG_RE = re.compile(r"[^A-Za-z0-9_.-]+")
 
-# What a schedule fires: a web-app agent, or a local plan (a task file run through
-# ``sdk.plan_run`` — the same pipeline a ticket gets, with no ticket).
-KINDS = ("agent", "plan")
+# What a schedule fires: a web-app agent, a local plan (a task file run through
+# ``sdk.plan_run`` — the same pipeline a ticket gets, with no ticket), or named
+# Jira tickets (``agentos-auto ticket <keys> [--agent ID]``, queued behind a busy loop).
+KINDS = ("agent", "plan", "tickets")
 
 # Where a run's files are copied, in addition to the agent's own output folder:
 # ``flat`` drops them straight into ``output_dir``; ``timestamp`` makes a fresh
@@ -272,12 +273,15 @@ def create(agent: str, cron: str = "", *, timezone_name: str = "Asia/Karachi",
            variables: dict | None = None, agent_id: str = "",
            scope: str = "custom", enabled: bool = True,
            run_at: str = "", kind: str = "agent", task_file: str = "",
-           output_dir: str = "", output_layout: str = "flat") -> dict:
+           output_dir: str = "", output_layout: str = "flat",
+           ticket_keys: list[str] | None = None) -> dict:
     """Persist a new schedule. Raises ``ValueError`` on anything unusable.
 
     Exactly one of ``cron`` (recurring) and ``run_at`` (once, at that local date
     and time) must be given. ``kind="plan"`` fires ``task_file`` through the local
     coding pipeline instead of an agent; ``agent`` is then just its display name.
+    ``kind="tickets"`` runs ``ticket_keys`` through ``agentos-auto ticket``, with
+    ``agent_id`` (when set) overriding each ticket's own agent.
     """
     if not _valid_agent_name(agent):
         raise ValueError(f"invalid agent name: {agent!r}")
@@ -286,6 +290,9 @@ def create(agent: str, cron: str = "", *, timezone_name: str = "Asia/Karachi",
         raise ValueError(f"kind must be one of {', '.join(KINDS)}")
     if kind == "plan" and not str(task_file or "").strip():
         raise ValueError("a plan schedule needs a task file")
+    keys = [str(k).strip().upper() for k in (ticket_keys or []) if str(k).strip()]
+    if kind == "tickets" and not keys:
+        raise ValueError("a tickets schedule needs at least one ticket key")
 
     cron = (cron or "").strip()
     run_at_utc = ""
@@ -310,6 +317,7 @@ def create(agent: str, cron: str = "", *, timezone_name: str = "Asia/Karachi",
         # is by name, so a rename would otherwise orphan the schedule silently.
         "agent_id": str(agent_id or ""),
         "task_file": str(task_file or "").strip(),
+        "ticket_keys": keys,
         "scope": scope,
         "cron": cron,
         "run_at": run_at_utc,

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.84}/sdk/browser_profile.py

@@ -202,15 +202,9 @@ def busy_pid() -> int | None:
         pid = int(raw)
     except ValueError:
         return None
-    try:
-        os.kill(pid, 0)
-    except ProcessLookupError:
-        return None
-    except PermissionError:
-        return pid          # alive, owned by someone else
-    except OSError:
-        return None
-    return pid
+    # run_auto's probe: ``os.kill(pid, 0)`` on Windows is TerminateProcess.
+    from sdk import run_auto
+    return pid if run_auto._pid_alive(pid) else None
 
 
 async def fetch_dom(url: str, *, timeout: float = _FETCH_TIMEOUT_S) -> Fetched:

devops_bot_sdk-1.6.84/sdk/claude_usage.py

@@ -0,0 +1,136 @@
+"""Claude plan usage gate — keeps scheduled runs inside the subscription limits.
+
+The scheduler fires agents around the clock to keep the VPS busy. Each run is a
+whole ``claude`` process billed against the same 5-hour and 7-day windows the
+person's own ticket work uses, so filler work must yield BEFORE the windows
+fill, not after a run dies with "usage limit reached" (``sdk.local_exec`` only
+detects the limit once it has already been hit).
+
+The numbers come from the same endpoint Claude Code's own ``/usage`` reads,
+authenticated with the CLI's OAuth token in ``~/.claude/.credentials.json``.
+It is not a documented API, so this module FAILS OPEN: no credentials, a
+network error or an unexpected shape all report "allowed". The limit-hit
+detection in ``local_exec`` is still the backstop in that case.
+
+Config — process env OR ``~/.agentos/.env``, all optional:
+  ``AGENTOS_USAGE_GATE``          ``0``/``false``/``no``/``off`` disables the gate.
+  ``AGENTOS_USAGE_MAX_5H_PCT``    skip scheduled runs at/above this 5-hour % (default 60).
+  ``AGENTOS_USAGE_MAX_7D_PCT``    skip scheduled runs at/above this 7-day % (default 75).
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import time
+import urllib.request
+from pathlib import Path
+
+logger = logging.getLogger("sdk.claude_usage")
+
+USAGE_URL = "https://api.anthropic.com/api/oauth/usage"
+CREDENTIALS = Path.home() / ".claude" / ".credentials.json"
+
+DEFAULT_MAX_5H_PCT = 60.0
+DEFAULT_MAX_7D_PCT = 75.0
+
+# One fetch serves every schedule due in the same few minutes.
+_CACHE_TTL_S = 300.0
+_TIMEOUT_S = 10.0
+
+_cache: dict = {"at": 0.0, "data": None}
+
+
+def _setting(name: str) -> str:
+    raw = os.environ.get(name)
+    if raw is not None and str(raw).strip() != "":
+        return str(raw).strip()
+    try:
+        from sdk.config import _dotenv_value
+        return (_dotenv_value(name) or "").strip()
+    except Exception:  # noqa: BLE001
+        return ""
+
+
+def enabled() -> bool:
+    return (_setting("AGENTOS_USAGE_GATE") or "1").lower() not in ("0", "false", "no", "off")
+
+
+def _pct(name: str, default: float) -> float:
+    raw = _setting(name)
+    if not raw:
+        return default
+    try:
+        return max(0.0, float(raw))
+    except ValueError:
+        logger.warning("claude_usage.bad_threshold %s=%r — using %s", name, raw, default)
+        return default
+
+
+def _token() -> str:
+    try:
+        data = json.loads(CREDENTIALS.read_text(encoding="utf-8"))
+        return str((data.get("claudeAiOauth") or {}).get("accessToken") or "")
+    except (OSError, ValueError, AttributeError):
+        return ""
+
+
+def fetch(*, force: bool = False) -> dict | None:
+    """The raw usage document, cached for a few minutes. None when unavailable."""
+    now = time.monotonic()
+    if not force and _cache["data"] is not None and now - _cache["at"] < _CACHE_TTL_S:
+        return _cache["data"]
+    token = _token()
+    if not token:
+        return None
+    req = urllib.request.Request(USAGE_URL, headers={
+        "Authorization": f"Bearer {token}",
+        "anthropic-beta": "oauth-2025-04-20",
+        "User-Agent": "agentos-sdk",
+    })
+    try:
+        with urllib.request.urlopen(req, timeout=_TIMEOUT_S) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+    except Exception as exc:  # noqa: BLE001 — fail open, never break the scheduler
+        logger.info("claude_usage.fetch_failed err=%s", exc)
+        return None
+    if not isinstance(data, dict):
+        return None
+    _cache.update(at=now, data=data)
+    return data
+
+
+def _window(data: dict, key: str) -> tuple[float | None, str]:
+    win = data.get(key)
+    if not isinstance(win, dict):
+        return None, ""
+    try:
+        return float(win.get("utilization")), str(win.get("resets_at") or "")
+    except (TypeError, ValueError):
+        return None, ""
+
+
+def check(data: dict | None = None) -> dict:
+    """``{"allowed", "reason", "five_hour", "seven_day"}`` for a scheduled run now.
+
+    ``allowed`` is False only when a window is known to be at/above its
+    threshold; anything unknown is allowed.
+    """
+    out = {"allowed": True, "reason": "", "five_hour": None, "seven_day": None}
+    if not enabled():
+        return out
+    data = data if data is not None else fetch()
+    if not data:
+        return out
+    for key, label, env, default in (
+        ("five_hour", "5-hour", "AGENTOS_USAGE_MAX_5H_PCT", DEFAULT_MAX_5H_PCT),
+        ("seven_day", "7-day", "AGENTOS_USAGE_MAX_7D_PCT", DEFAULT_MAX_7D_PCT),
+    ):
+        used, resets = _window(data, key)
+        out[key] = used
+        limit = _pct(env, default)
+        if used is not None and used >= limit and out["allowed"]:
+            out["allowed"] = False
+            out["reason"] = (f"Claude {label} usage {used:.0f}% ≥ {limit:.0f}% cap"
+                             + (f" (resets {resets})" if resets else ""))
+    return out

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.84}/sdk/cli.py

@@ -231,13 +231,28 @@ def main() -> None:
         _fallback_command(rest)
         return
 
+    if noun == "help":
+        # `agentos help -h` is the command list; `agentos help <problem>` (or bare
+        # `agentos help` on a terminal, which asks for one) is DevOps Bot Help.
+        if rest[:1] in (["-h"], ["--help"]):
+            _print_usage()
+            return
+        from sdk import helpdesk
+        sys.exit(helpdesk.cli(rest))
+
+    if noun == "doctor":
+        from sdk import helpdesk
+        sys.exit(helpdesk.doctor())
+
     _print_usage()
     sys.exit(1)
 
 
 def _print_usage() -> None:
-    print("usage: agentos <configure|chat|agent|ticket|integration|default-agents|agentd|github|report|browser|fallback|firewall|activity-setup|swagger> ...")
+    print("usage: agentos <configure|chat|agent|ticket|integration|default-agents|agentd|github|report|browser|fallback|help|doctor|firewall|activity-setup|swagger> ...")
     print()
+    print('  agentos help "<your problem>"      # DevOps Bot Help: reads your logs + the SDK, tells you the fix')
+    print("  agentos doctor                     # collect a diagnostics bundle to send to your admin (no AI)")
     print("  agentos configure [--rotate]")
     print("  agentos chat [--product-id ID] [--pv-id ID] [--no-autorun]   # requirements → ticket")
     print("  agentos agent <list|run NAME|chat NAME MSG|logs NAME|enable NAME|disable NAME|rm NAME>")
@@ -1383,7 +1398,7 @@ def _browser_command(args: list[str]) -> None:
 # ── fallback ─────────────────────────────────────────────────────────────
 
 def _fallback_usage() -> None:
-    print("usage: agentos fallback install                 # where `ad` is, or how to install it")
+    print("usage: agentos fallback install                 # install `ad`, or update an outdated one")
     print("       agentos fallback login [--browser | --api-key [KEY]] [--base-url URL] [--no-browser]")
     print("       agentos fallback status [--verify]       # --verify asks the server too")
     print("       agentos fallback logout")
@@ -1411,8 +1426,11 @@ def _fallback_command(args: list[str]) -> None:
         if le._fallback_disabled():
             print("error: the fallback is disabled (AGENTOS_FALLBACK_CLI=off)")
             sys.exit(1)
-        # The SDK no longer installs the CLI: it is updated continuously, so the
-        # copy on the machine is the one to use. This only reports where it is.
+        # Installs the CLI when it is missing, and replaces an outdated one (the old
+        # package name, or a release older than FALLBACK_MIN_VERSION).
+        done = le.upgrade_fallback_cli(install_missing=True)
+        if done:
+            print(done)
         cli = le.fallback_cli_path()
         if not cli:
             print(f"error: the AI Draftsman CLI (`ad`) was not found. Install it with:\n"

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.84}/sdk/client.py

@@ -19,6 +19,7 @@ import json
 import logging
 import os
 import random
+import re
 from typing import Any, AsyncGenerator
 
 import httpx
@@ -97,6 +98,69 @@ def is_retryable_backend_error(status_code: int, body: str) -> bool:
     return status_code in (408, 429) or status_code >= 500
 
 
+#: How many times set_task_status waits out a 429 before giving up on a ticket.
+_RATE_LIMIT_RETRIES = 3
+_RETRY_AFTER_DEFAULT_S = 60.0
+_RETRY_AFTER_MAX_S = 120.0
+
+
+def _retry_after_seconds(resp: httpx.Response) -> float:
+    """Seconds to wait after a 429: the Retry-After header, else the "retry after N
+    seconds" the backend puts in its message, else 60. Capped so a bad value can't
+    hang the CLI."""
+    raw = resp.headers.get("retry-after", "")
+    match = re.search(r"retry after (\d+)", resp.text or "", re.IGNORECASE)
+    for candidate in (raw, match.group(1) if match else ""):
+        try:
+            secs = float(candidate)
+        except (TypeError, ValueError):
+            continue
+        if secs > 0:
+            return min(secs, _RETRY_AFTER_MAX_S)
+    return _RETRY_AFTER_DEFAULT_S
+
+
+#: Statuses where the backend refused the request WITHOUT acting on it, so a retry
+#: cannot duplicate a create. 401 is here because the backend intermittently fails
+#: to verify a perfectly good token (its profile lookup blips) — the same request
+#: succeeds a moment later. A plain 500 / read timeout is deliberately NOT: a POST
+#: may already have created the ticket or agent.
+_SAFE_RETRY_STATUSES = (401, 408, 429, 502, 503, 504)
+_SAFE_RETRY_ATTEMPTS = 3
+_SAFE_RETRY_MAX_WAIT_S = 30.0
+
+
+async def _request_with_safe_retry(send, *, label: str) -> httpx.Response:
+    """Call ``send()`` (one HTTP request) and retry only failures where nothing was
+    processed.
+
+    Retries the statuses in ``_SAFE_RETRY_STATUSES``, a saturated DB pool, and a
+    connection that never opened (``httpx.ConnectError`` — the request was never
+    sent). Backoff 1s/2s/4s, or the server's Retry-After for a 429. Any other
+    exception propagates exactly as before.
+    """
+    for attempt in range(_SAFE_RETRY_ATTEMPTS + 1):
+        last = attempt == _SAFE_RETRY_ATTEMPTS
+        try:
+            resp = await send()
+        except httpx.ConnectError as exc:
+            if last:
+                raise
+            reason = f"connect error ({exc})"
+            wait = float(2 ** attempt)
+        else:
+            pool = any(m in (resp.text or "").lower() for m in _POOL_MARKERS)
+            if last or not (resp.status_code in _SAFE_RETRY_STATUSES or pool):
+                return resp
+            reason = f"HTTP {resp.status_code}"
+            wait = (min(_retry_after_seconds(resp), _SAFE_RETRY_MAX_WAIT_S)
+                    if resp.status_code == 429 else float(2 ** attempt))
+        logger.warning("client.%s %s — retrying in %ss (%d/%d)", label, reason, wait,
+                       attempt + 1, _SAFE_RETRY_ATTEMPTS)
+        await asyncio.sleep(wait)
+    raise AssertionError("unreachable")  # pragma: no cover
+
+
 def _notify_status(task_id: str, status: str) -> None:
     for cb in list(_status_observers):
         try:
@@ -1369,9 +1433,31 @@ class BackendClient:
             k: v for k, v in self._headers.items() if k.lower() != "content-type"
         }
         headers.update({"accept": "*/*", "developer-name": "null", "product": ""})
+        async def _put(client: httpx.AsyncClient, value: str) -> httpx.Response:
+            # A bulk `set-status` (dozens of tickets) trips the backend's rate limit
+            # ("Too many requests. Please retry after 60 seconds."). Wait it out and
+            # retry, so the batch slows down instead of failing every remaining ticket.
+            for attempt in range(_RATE_LIMIT_RETRIES + 1):
+                resp = await client.put(url, files={"status": (None, value)}, headers=headers)
+                if resp.status_code != 429 or attempt == _RATE_LIMIT_RETRIES:
+                    return resp
+                wait = _retry_after_seconds(resp)
+                logger.warning("client.set_task_status rate-limited task=%s — waiting %ss "
+                               "(retry %d/%d)", task_id, wait, attempt + 1, _RATE_LIMIT_RETRIES)
+                await asyncio.sleep(wait)
+            return resp
+
         try:
             async with httpx.AsyncClient(timeout=20.0) as client:
-                resp = await client.put(url, files={"status": (None, status)}, headers=headers)
+                resp = await _put(client, status)
+                # A ticket left In Progress by a loop that died mid-run has no running
+                # timer, and the backend refuses to move it anywhere without one. Start
+                # a timer (re-mark In Progress) and retry once — the same blip the
+                # reject path does before move_to_backlog.
+                if (resp.status_code >= 400 and "no running timer" in resp.text.lower()
+                        and status.strip().lower() != "in progress"):
+                    await _put(client, "In Progress")
+                    resp = await _put(client, status)
             if resp.status_code >= 400:
                 logger.warning("client.set_task_status failed task=%s status=%s body=%s",
                                task_id, resp.status_code, resp.text[:200])
@@ -1552,7 +1638,9 @@ class BackendClient:
         files = to_multipart(fields, model_used)
         try:
             async with httpx.AsyncClient(timeout=30.0) as client:
-                resp = await client.post(url, files=files, headers=headers)
+                resp = await _request_with_safe_retry(
+                    lambda: client.post(url, files=files, headers=headers),
+                    label="create_task_ml")
             if resp.status_code >= 400:
                 try:
                     self.last_task_ml_error = resp.json() or {}
@@ -2546,8 +2634,10 @@ class BackendClient:
         setattr(self, err_attr, {})
         try:
             async with httpx.AsyncClient(timeout=timeout) as client:
-                resp = await client.request(method, self._url(path), json=json,
-                                            headers=self._headers)
+                resp = await _request_with_safe_retry(
+                    lambda: client.request(method, self._url(path), json=json,
+                                           headers=self._headers),
+                    label=f"{method} {path}")
             if resp.status_code >= 400:
                 setattr(self, err_attr, self._error_record(resp))
                 logger.warning("client.%s %s failed status=%s body=%s", method, path,