devops-bot-sdk 1.6.66__tar.gz → 1.6.69__tar.gz

{devops_bot_sdk-1.6.66 → devops_bot_sdk-1.6.69}/PKG-INFO

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

{devops_bot_sdk-1.6.66 → devops_bot_sdk-1.6.69}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.66 → devops_bot_sdk-1.6.69}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ sdk/py.typed
 sdk/resume.py
 sdk/router.py
 sdk/run_auto.py
+sdk/schedule_tickets.py
 sdk/scheduler.py
 sdk/self_report.py
 sdk/self_report_local.py
@@ -203,7 +204,9 @@ tests/test_run_outputs.py
 tests/test_run_verdict_is_honest.py
 tests/test_schedule_api.py
 tests/test_schedule_outputs_and_plans.py
+tests/test_schedule_tickets.py
 tests/test_scheduler.py
+tests/test_scheduler_transient_retry.py
 tests/test_self_report.py
 tests/test_service_token_warning.py
 tests/test_stale_panel_restart.py
@@ -224,4 +227,5 @@ 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_windows_task_paths.py
 tests/test_write_hook.py

{devops_bot_sdk-1.6.66 → devops_bot_sdk-1.6.69}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.6.66
+Version: 1.6.69
 
 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.66"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.69"   # 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.66 → devops_bot_sdk-1.6.69}/sdk/agents/chat.py

@@ -41,6 +41,52 @@ def _tee_events(log_path, on_event: "EventHandler | None") -> "EventHandler":
 EventHandler = Callable[[dict], Awaitable[None]]
 
 
+#: Pauses between attempts when an agent list cannot be read. The AI backend
+#: verifies the co_ token against the ML gateway on every call and that check
+#: flakes (a spurious 401 or a dropped connection for a few seconds), which made a
+#: scheduled run give up on the first miss. Short, because a human may be waiting.
+_LOOKUP_RETRY_DELAYS_S: tuple[float, ...] = (2.0, 5.0)
+
+
+async def _fetch_rows(fetch) -> list[dict]:
+    """``fetch()`` with brief retries; raises the last error when every attempt fails."""
+    import asyncio
+
+    last: Exception | None = None
+    for delay in (0.0, *_LOOKUP_RETRY_DELAYS_S):
+        if delay:
+            await asyncio.sleep(delay)
+        try:
+            return await fetch() or []
+        except Exception as exc:  # noqa: BLE001 — classified by the caller
+            last = exc
+    assert last is not None
+    raise last
+
+
+async def _gateway_manifest(client, name: str):
+    """The agent from the ML gateway's listing, or ``None``.
+
+    The gateway reads the same ``agents`` table the AI backend re-projects, with no
+    second token-verification hop, so it stays readable when the backend flakes.
+    Consulted only after a backend source could not be read.
+    """
+    from sdk.agents.manifest import manifest_from_backend_row
+
+    fetch = getattr(client, "list_gateway_agents_by_scope", None)
+    if fetch is None:
+        return None
+    try:
+        scopes = await fetch() or {}
+    except Exception:  # noqa: BLE001 — the fallback failing changes nothing
+        return None
+    for scope in ("personal", "department"):
+        for row in scopes.get(scope) or []:
+            if isinstance(row, dict) and row.get("name") == name:
+                return manifest_from_backend_row(row)
+    return None
+
+
 class AgentLookupUnavailable(LookupError):
     """The agent could not be found, but at least one source could not be READ.
 
@@ -88,7 +134,7 @@ async def resolve_agent(name: str, client=None) -> AgentManifest:
         if fetch is None:
             continue
         try:
-            rows = await fetch() or []
+            rows = await _fetch_rows(fetch)
         except Exception as exc:  # noqa: BLE001 — a fetch failure is not "not found"
             unreadable = True
             reasons.append(f"{label} could not be fetched ({str(exc) or type(exc).__name__})")
@@ -107,6 +153,10 @@ async def resolve_agent(name: str, client=None) -> AgentManifest:
         "not in ~/.agentos/agents/, your backend agents, or your department defaults"
     )
     if unreadable:
+        manifest = await _gateway_manifest(client, name)
+        if manifest is not None:
+            logger.info("agent lookup fell back to the ML gateway listing for %r", name)
+            return manifest
         # Do NOT say "no agent named …" here: a source went unread, so absence was
         # never established. Claiming it sends the user hunting for a typo when the
         # fix is a token or a network.

devops_bot_sdk-1.6.69/sdk/schedule_tickets.py

@@ -0,0 +1,201 @@
+"""A Jira ticket per scheduled run: open it, mark it In Progress, close it on proof.
+
+Opt-in per schedule with a ``ticket`` block on the schedule record::
+
+    "ticket": {"project_key": "DBNF", "type": "Task", "priority": "Low"}
+
+Lifecycle, driven by ``sdk.scheduler.fire``:
+
+  1. ``open_ticket``  — POST /tasks-ml, then PUT status "In Progress".
+  2. the agent runs exactly as it would without a ticket.
+  3. ``close_ticket`` — "Done" only when the run succeeded AND its output file
+     exists and was written during this run (``evidence_path``); otherwise
+     "backlog" with the reason appended to the description.
+
+Uses the ML gateway's /tasks-ml directly (``create_task_ml`` / ``update_task_ml``),
+the same calls the Epic decomposition already relies on, so it works without any
+backend deploy. Every function here is best-effort and never raises: a ticket is
+bookkeeping, and losing a nightly run because Jira was slow would be the wrong
+trade. The lowercase "backlog" is deliberate — the gateway validates against
+``{To Do, In Progress, Done, backlog}`` and 400s on "Backlog".
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+logger = logging.getLogger("sdk.schedule_tickets")
+
+DONE = "Done"
+IN_PROGRESS = "In Progress"
+BACKLOG = "backlog"
+_MAX_REASON = 500
+
+
+@dataclass
+class RunTicket:
+    task_id: str
+    key: str
+    description: str
+
+
+def to_record(ticket: RunTicket | None) -> dict | None:
+    """Plain dict to persist on the schedule while a run is being retried."""
+    if ticket is None:
+        return None
+    return {"task_id": ticket.task_id, "key": ticket.key, "description": ticket.description}
+
+
+def from_record(record) -> RunTicket | None:
+    """The ticket a previous attempt of this run opened, if one was persisted."""
+    if not isinstance(record, dict) or not record.get("task_id"):
+        return None
+    return RunTicket(task_id=str(record["task_id"]), key=str(record.get("key") or ""),
+                     description=str(record.get("description") or ""))
+
+
+def enabled(schedule: dict) -> bool:
+    cfg = schedule.get("ticket")
+    return isinstance(cfg, dict) and bool(str(cfg.get("project_key") or "").strip())
+
+
+def _summary(schedule: dict, when: datetime) -> str:
+    variables = schedule.get("variables") or {}
+    target = variables.get("repo") or ""
+    branch = variables.get("branch") or ""
+    if target and branch:
+        target = f"{target}@{branch}"
+    parts = ["[Scheduled]", str(schedule.get("agent") or "agent")]
+    if target:
+        parts.append(f"— {target}")
+    parts.append(f"— {when:%Y-%m-%d}")
+    return " ".join(parts)[:255]
+
+
+def _description(schedule: dict, expected: str) -> str:
+    variables = schedule.get("variables") or {}
+    lines = [
+        f"Automated run of agent '{schedule.get('agent')}' by the AgentOS scheduler.",
+        f"Schedule: {schedule.get('cron') or schedule.get('run_at')} ({schedule.get('timezone')}), "
+        f"id {schedule.get('schedule_id')}.",
+    ]
+    if expected:
+        lines.append(f"Output: {expected}")
+    shown = {k: v for k, v in variables.items() if k in ("repo", "repo_path", "branch", "output_file")}
+    if shown:
+        lines.append("Inputs: " + ", ".join(f"{k}={v}" for k, v in shown.items()))
+    lines.append("Closed as Done only when the run succeeds and its output file is written.")
+    return "\n".join(lines)
+
+
+def expected_output(schedule: dict) -> str:
+    """The file (or folder) this run is expected to write, for the ticket text."""
+    variables = schedule.get("variables") or {}
+    return str(variables.get("output_file") or schedule.get("output_dir") or "")
+
+
+def evidence_path(schedule: dict, record: Path | None, delivered_to: str,
+                  started_at: datetime) -> tuple[Path | None, str]:
+    """``(path, "")`` when the run's output exists and is fresh, else ``(None, why)``.
+
+    The agent's own ``output_file`` variable is the strongest proof (the per-repo
+    suggestion and quality files). Failing that, the run record copied into the
+    schedule's export folder (the AI Research Agent's daily file). Failing that,
+    the run record itself.
+    """
+    variables = schedule.get("variables") or {}
+    want = str(variables.get("output_file") or "").strip()
+    if want:
+        candidate = Path(want).expanduser()
+    elif delivered_to and record is not None:
+        candidate = Path(delivered_to) / Path(record).name
+    elif record is not None:
+        candidate = Path(record)
+    else:
+        return None, "the run produced no output file"
+    try:
+        stat = candidate.stat()
+    except OSError:
+        return None, f"output file was not created: {candidate}"
+    written = datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc)
+    if written < started_at.replace(microsecond=0):
+        return None, f"output file was not updated by this run: {candidate}"
+    return candidate, ""
+
+
+async def _owner_email(client) -> str:
+    try:
+        return str((await client.profile()).email or "").strip()
+    except Exception:  # noqa: BLE001
+        return ""
+
+
+async def open_ticket(client, schedule: dict, when: datetime | None = None) -> RunTicket | None:
+    """Create the run's ticket and move it to In Progress. ``None`` on any failure."""
+    if not enabled(schedule):
+        return None
+    cfg = schedule["ticket"]
+    when = when or datetime.now(timezone.utc)
+    description = _description(schedule, expected_output(schedule))
+    fields = {
+        "projectKey": str(cfg["project_key"]).strip(),
+        "type": str(cfg.get("type") or "Task"),
+        "priority": str(cfg.get("priority") or "Low"),
+        "summary": _summary(schedule, when),
+        "description": description,
+    }
+    email = await _owner_email(client)
+    if email:
+        fields["assigneeEmail"] = email
+    try:
+        task_id = await client.create_task_ml(fields)
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("schedule_tickets.create_failed sid=%s err=%s", schedule.get("schedule_id"), exc)
+        return None
+    if not task_id:
+        logger.warning("schedule_tickets.create_failed sid=%s detail=%s",
+                       schedule.get("schedule_id"), getattr(client, "last_task_ml_error", ""))
+        return None
+    key = ""
+    try:
+        record = await client.get_task_ml(task_id) or {}
+        key = str(record.get("jiraIssueKey") or record.get("jiraKey") or "")
+    except Exception:  # noqa: BLE001 — the key is for display only
+        pass
+    ticket = RunTicket(task_id=str(task_id), key=key, description=description)
+    await _set_status(client, ticket, IN_PROGRESS)
+    return ticket
+
+
+async def _set_status(client, ticket: RunTicket, status: str, extra: dict | None = None) -> bool:
+    try:
+        ok = await client.update_task_ml(ticket.task_id, {"status": status, **(extra or {})})
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("schedule_tickets.status_failed task=%s status=%s err=%s",
+                       ticket.task_id, status, exc)
+        return False
+    if not ok:
+        logger.warning("schedule_tickets.status_failed task=%s status=%s detail=%s",
+                       ticket.task_id, status, getattr(client, "last_task_ml_error", ""))
+    return bool(ok)
+
+
+async def close_ticket(client, ticket: RunTicket | None, *, ok: bool, reason: str = "",
+                       output: Path | None = None) -> str:
+    """Done on proven success, backlog otherwise. Returns the status set ("" if none)."""
+    if ticket is None:
+        return ""
+    if ok and output is not None:
+        done = await _set_status(client, ticket, DONE,
+                                 {"description": f"{ticket.description}\nResult: {output}"})
+        return DONE if done else ""
+    why = (reason or "the run did not complete").strip()[:_MAX_REASON]
+    moved = await _set_status(client, ticket, BACKLOG,
+                              {"description": f"{ticket.description}\nFailed: {why}"})
+    return BACKLOG if moved else ""
+
+
+def label(ticket: RunTicket | None) -> str:
+    return (ticket.key or ticket.task_id) if ticket else ""

{devops_bot_sdk-1.6.66 → devops_bot_sdk-1.6.69}/sdk/scheduler.py

@@ -56,6 +56,17 @@ _MAX_JITTER_S = 60.0
 
 _semaphore: asyncio.Semaphore | None = None
 _running: set[str] = set()          # schedule_ids currently in flight, this process
+# schedule_ids dispatched and not yet finished — including ones still WAITING for
+# the semaphore. mark_fired only runs once fire() starts, so without this a due
+# schedule queued behind a long run was re-dispatched on every tick and then ran
+# once per queued copy.
+_queued: set[str] = set()
+
+# A run whose agent could not be LOOKED UP (backend unreadable) is re-armed and
+# retried instead of being lost for the day: this many times, this far apart.
+# 3 x 5 min stays well inside the default 1 h catch-up grace window.
+MAX_TRANSIENT_RETRIES = 3
+TRANSIENT_RETRY_DELAY_S = 300.0
 
 
 def _setting(name: str) -> str:
@@ -202,10 +213,15 @@ async def fire(schedule: dict, *, client=None) -> dict:
         return out
 
     _running.add(sid)
+    # Kept so a transient lookup failure can re-arm the schedule (see below).
+    previous_fire = schedule.get("last_fire_at")
+    rearmed = False
     # Stamped BEFORE the run, not after: a long run, or one queued behind the
     # semaphore, would otherwise still look due on the next tick.
     schedules.mark_fired(sid)
     started = time.monotonic()
+    run_started = datetime.now(timezone.utc)
+    ticket = None   # sdk.schedule_tickets.RunTicket when the schedule opts in
 
     try:
         if schedule.get("kind") == "plan":
@@ -222,9 +238,16 @@ async def fire(schedule: dict, *, client=None) -> dict:
             out["status"] = "inactive"
             return out
 
+        from sdk import schedule_tickets
         from sdk.agents import activity
         from sdk.agents.chat import AgentLookupUnavailable, run_agent
 
+        # Opened only once the agent is known to be runnable, so a disabled agent
+        # never leaves a ticket behind. Best-effort: no ticket never blocks a run.
+        # A retry of the same run reuses the ticket its first attempt opened.
+        ticket = (schedule_tickets.from_record(schedule.get("open_ticket"))
+                  or await schedule_tickets.open_ticket(client, schedule, run_started))
+
         trigger = f"schedule · {schedule.get('cron')} ({schedule.get('timezone')})"
         try:
             result = await run_agent(
@@ -247,18 +270,46 @@ async def fire(schedule: dict, *, client=None) -> dict:
             # auto-disable — a few flaky minutes would otherwise switch off every
             # schedule on the box.
             transient = isinstance(exc, AgentLookupUnavailable)
+            attempt = int(schedule.get("transient_attempts") or 0) + 1
+            if transient and attempt <= MAX_TRANSIENT_RETRIES:
+                # The backend could not be READ: nothing ran. Put last_fire_at back
+                # so the schedule is due again, and hold it off for a few minutes,
+                # keeping the ticket open for the retry to reuse.
+                retry_at = datetime.now(timezone.utc).timestamp() + TRANSIENT_RETRY_DELAY_S
+                schedules.update(
+                    sid, last_fire_at=previous_fire, transient_attempts=attempt,
+                    retry_after=datetime.fromtimestamp(retry_at, timezone.utc)
+                    .isoformat(timespec="seconds"),
+                    open_ticket=schedule_tickets.to_record(ticket),
+                )
+                rearmed = True
+                schedules.mark_result(
+                    sid, ok=True,
+                    status=_with_ticket(
+                        f"retrying {attempt}/{MAX_TRANSIENT_RETRIES} in "
+                        f"{int(TRANSIENT_RETRY_DELAY_S // 60)} min — {exc}", ticket, ""),
+                )
+                logger.warning("scheduler.lookup_retry agent=%s attempt=%s err=%s",
+                               agent, attempt, exc)
+                out["status"] = "retrying"
+                return out
             result = {"ok": False, "error": str(exc), "result": "",
                       "input_tokens": 0, "output_tokens": 0, "cost_usd": 0.0,
                       "files_changed": []}
             path = run_log.start_run(agent, kind="scheduled", trigger=trigger,
                                      scope=str(schedule.get("scope") or "custom"))
             run_log.finish_run(path, result)
+            await schedule_tickets.close_ticket(client, ticket, ok=False, reason=str(exc))
             schedules.mark_result(
                 sid,
                 ok=transient,       # transient → no strike, but still reported
-                status=(f"retrying — {exc}" if transient else f"failed — {exc}"),
+                status=_with_ticket(
+                    f"gave up after {MAX_TRANSIENT_RETRIES} retries — {exc}" if transient
+                    else f"failed — {exc}", ticket, "backlog"),
                 output_file=path.name if path else "",
-                delivered_to=schedules.deliver(schedule, path),
+                # A failure record is never exported: the schedule's folder is
+                # where the person reads RESULTS (e.g. one research report a day).
+                delivered_to="",
             )
             logger.warning("scheduler.run_unrunnable agent=%s transient=%s err=%s",
                            agent, transient, exc)
@@ -268,15 +319,29 @@ async def fire(schedule: dict, *, client=None) -> dict:
         elapsed = time.monotonic() - started
         ok = bool(result.get("ok"))
         latest = run_log.list_runs(agent, limit=1)
+        record = latest[0] if latest else None
+        # Only a successful run is exported; a failure stays in the agent's own
+        # run history, so the export folder never holds an error as a "report".
+        delivered_to = schedules.deliver(
+            schedule, record,
+            list(result.get("files_changed") or []),
+            workspace=_agent_workspace(agent),
+        ) if ok else ""
+        ticket_status = ""
+        if ticket is not None:
+            output, missing = schedule_tickets.evidence_path(
+                schedule, record, delivered_to, run_started)
+            reason = (str(result.get("error") or "the agent reported a failure")
+                      if not ok else missing)
+            ticket_status = await schedule_tickets.close_ticket(
+                client, ticket, ok=ok and output is not None, reason=reason, output=output)
         schedules.mark_result(
             sid, ok=ok,
-            status="ok" if ok else f"failed — {str(result.get('error') or '')[:200]}",
-            output_file=latest[0].name if latest else "",
-            delivered_to=schedules.deliver(
-                schedule, latest[0] if latest else None,
-                list(result.get("files_changed") or []),
-                workspace=_agent_workspace(agent),
-            ),
+            status=_with_ticket(
+                "ok" if ok else f"failed — {str(result.get('error') or '')[:200]}",
+                ticket, ticket_status),
+            output_file=record.name if record else "",
+            delivered_to=delivered_to,
         )
         # One call writes BOTH the local usage ledger and the backend
         # agent_activities feed, and never raises.
@@ -287,10 +352,19 @@ async def fire(schedule: dict, *, client=None) -> dict:
 
     except Exception as exc:  # noqa: BLE001 — a bad run must never end the loop
         logger.warning("scheduler.fire_failed agent=%s err=%s", agent, exc)
-        schedules.mark_result(sid, ok=False, status=f"failed — {exc}")
+        if ticket is not None:
+            try:
+                from sdk import schedule_tickets
+                await schedule_tickets.close_ticket(client, ticket, ok=False, reason=str(exc))
+            except Exception:  # noqa: BLE001 — never let ticket bookkeeping escape
+                pass
+        schedules.mark_result(sid, ok=False, status=_with_ticket(f"failed — {exc}", ticket, "backlog"))
         out["status"] = "failed"
         return out
     finally:
+        if not rearmed and any(schedule.get(k) for k in ("transient_attempts", "retry_after", "open_ticket")):
+            # The run reached a real outcome: clear any retry state it carried.
+            schedules.update(sid, transient_attempts=0, retry_after="", open_ticket=None)
         _running.discard(sid)
         release_lock(agent)
         try:
@@ -299,6 +373,14 @@ async def fire(schedule: dict, *, client=None) -> dict:
             pass
 
 
+def _with_ticket(status: str, ticket, ticket_status: str) -> str:
+    """Append the run's ticket to the schedule's status line, when it has one."""
+    if ticket is None:
+        return status
+    key = ticket.key or ticket.task_id
+    return f"{status} · ticket {key}" + (f" → {ticket_status}" if ticket_status else "")
+
+
 def _agent_workspace(agent: str) -> Path | None:
     """The directory the agent ran in — where any file it wrote lives."""
     try:
@@ -371,9 +453,13 @@ async def _fire_guarded(schedule: dict) -> None:
     global _semaphore
     if _semaphore is None:
         _semaphore = asyncio.Semaphore(concurrency())
-    async with _semaphore:
-        await asyncio.sleep(random.uniform(0, _MAX_JITTER_S))
-        await fire(schedule)
+    sid = str(schedule.get("schedule_id") or "")
+    try:
+        async with _semaphore:
+            await asyncio.sleep(random.uniform(0, _MAX_JITTER_S))
+            await fire(schedule)
+    finally:
+        _queued.discard(sid)
 
 
 # ── The loop ────────────────────────────────────────────────────────────────
@@ -383,13 +469,30 @@ def due_now(now: datetime | None = None) -> list[dict]:
     edit in the panel takes effect on the next tick with no restart."""
     now = now or datetime.now(timezone.utc)
     grace = grace_s()
-    return [s for s in schedules.list_schedules() if schedules.is_due(s, now, grace)]
+    return [s for s in schedules.list_schedules()
+            if schedules.is_due(s, now, grace) and not _held_off(s, now)]
+
+
+def _held_off(schedule: dict, now: datetime) -> bool:
+    """True while a re-armed schedule is waiting out its retry delay."""
+    raw = schedule.get("retry_after")
+    if not raw:
+        return False
+    try:
+        until = datetime.fromisoformat(str(raw))
+    except ValueError:
+        return False
+    if until.tzinfo is None:
+        until = until.replace(tzinfo=timezone.utc)
+    return now < until
 
 
 async def tick(now: datetime | None = None) -> int:
     """One evaluation pass. Returns how many runs were dispatched."""
-    ready = due_now(now)
+    ready = [s for s in due_now(now)
+             if str(s.get("schedule_id") or "") not in _queued]
     for schedule in ready:
+        _queued.add(str(schedule.get("schedule_id") or ""))
         asyncio.ensure_future(_fire_guarded(schedule))
     return len(ready)
 
@@ -429,6 +532,7 @@ def status() -> dict:
         "total": len(rows),
         "active": sum(1 for s in rows if s.get("enabled", True)),
         "in_flight": sorted(_running),
+        "queued": sorted(_queued - _running),
         "next": [
             {
                 "schedule_id": s.get("schedule_id"),