devops-bot-sdk 1.6.68__tar.gz → 1.6.70__tar.gz

{devops_bot_sdk-1.6.68 → devops_bot_sdk-1.6.70}/PKG-INFO

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

{devops_bot_sdk-1.6.68 → devops_bot_sdk-1.6.70}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.68 → devops_bot_sdk-1.6.70}/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
@@ -52,6 +53,7 @@ sdk/tickets.py
 sdk/updater.py
 sdk/url_access.py
 sdk/vps_health.py
+sdk/vps_identity.py
 sdk/write_hook.py
 sdk/activity/__init__.py
 sdk/activity/classifier.py
@@ -203,7 +205,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
@@ -223,6 +227,7 @@ tests/test_updater_pep668.py
 tests/test_updater_reports_the_truth.py
 tests/test_url_access.py
 tests/test_vps_health.py
+tests/test_vps_only_reporting.py
 tests/test_windows_loop_identity.py
 tests/test_windows_task_paths.py
 tests/test_write_hook.py

{devops_bot_sdk-1.6.68 → devops_bot_sdk-1.6.70}/sdk/__init__.py

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

@@ -188,6 +188,11 @@ def _flag_value() -> str:
                 return value.strip().strip('"').strip("'")
     except OSError:
         pass
+    # Under sudo, settings.setting reads ROOT's .env. Falling back to it made a
+    # flag left in /root/.agentos/.env answer for the panel user, so _enable_flag
+    # never wrote theirs and the collector never started — on every restart.
+    if _is_privileged() and _panel_user() is not None:
+        return ""
     return settings.setting(AUDIT_FLAG)
 
 

{devops_bot_sdk-1.6.68 → devops_bot_sdk-1.6.70}/sdk/activity/shipper.py

@@ -176,12 +176,57 @@ async def flush_once(
     return result
 
 
+def discard_spool(spool: Spool | None = None) -> int:
+    """Delete everything queued, without sending it. Returns the rows dropped."""
+    spool = spool or settings.get_spool()
+    dropped = 0
+    while True:
+        chunk = spool.next_chunk()
+        if not chunk:
+            return dropped
+        dropped += len(chunk)
+        spool.ack(chunk)
+
+
+async def ship_tick(
+    is_vps: Callable[[], Awaitable[bool | None]] | None = None,
+) -> FlushResult | None:
+    """One cron tick: ship only from the caller's assigned VPS.
+
+    The relay files every batch under the TOKEN's VPS, so a laptop running the SDK
+    with the same token put its own events in the VPS's audit trail. On a machine
+    that is definitely not the VPS the queue is discarded — kept, it would only grow
+    forever, since that machine will never be allowed to send it. When the answer
+    is unknown (profile unreachable) everything is kept for the next tick.
+    """
+    if is_vps is None:
+        from sdk import vps_identity
+        is_vps = vps_identity.is_assigned_vps
+    try:
+        verdict = await is_vps()
+    except Exception:  # noqa: BLE001 — is_assigned_vps never raises, but be certain
+        verdict = None
+    if verdict is None:
+        return None
+    if verdict is False:
+        try:
+            dropped = discard_spool()
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("activity: could not discard the spool: %s", exc)
+            return None
+        if dropped:
+            logger.info("activity.not_assigned_vps discarded=%d (this machine is not the "
+                        "user's VPS; nothing is shipped from it)", dropped)
+        return None
+    return await flush_once()
+
+
 async def run_forever(interval_s: float | None = None, *, initial_delay_s: float = 30.0) -> None:
     """Flush every ``interval_s`` (default 5 minutes) until cancelled."""
     await asyncio.sleep(initial_delay_s)
     while True:
         try:
-            await flush_once()
+            await ship_tick()
             every = interval_s if interval_s is not None else settings.ship_interval_seconds()
             await asyncio.sleep(every)
         except asyncio.CancelledError:

{devops_bot_sdk-1.6.68 → devops_bot_sdk-1.6.70}/sdk/agents/activity.py

@@ -79,7 +79,7 @@ def describe(name: str, kind: str, result: dict | None, duration_s: float = 0.0,
 #     per-run event. So an agent run costs one POST no matter how chatty it is.
 _LINE_BUF: dict[str, list[str]] = {}
 _LINE_BUF_MAX_LINES = 40          # keep the tail — recent lines are the useful ones
-_LINE_BUF_MAX_CHARS = 4000        # bounded like _ACTIVITY_FLUSH_MAX_CHARS
+_LINE_BUF_MAX_CHARS = 4000        # trimmed to the gateway limit by client._fit_activity
 
 
 def note(bucket: str, text: str) -> None:

{devops_bot_sdk-1.6.68 → devops_bot_sdk-1.6.70}/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.68 → devops_bot_sdk-1.6.70}/sdk/client.py

@@ -121,9 +121,19 @@ def _notify_status(task_id: str, status: str) -> None:
 # `logger.info` line regardless of whether it buffers or POSTs.
 _ACTIVITY_FLUSH_MIN_S = float(os.getenv("AGENTOS_ACTIVITY_FLUSH_MIN_S", "") or 180.0)
 _ACTIVITY_FLUSH_MAX_S = float(os.getenv("AGENTOS_ACTIVITY_FLUSH_MAX_S", "") or 300.0)
-# Cap the coalesced payload so one flush can't POST a multi-megabyte body after a
-# very long, chatty run; keep the tail (most recent lines are the most useful).
-_ACTIVITY_FLUSH_MAX_CHARS = 8000
+# The gateway rejects an `activity` over 2000 characters with a 400 ("Activity
+# must be shorter than or equal to 2000 characters"). The cap used to be 8000, so
+# every coalesced flush and every long scheduled-run summary was refused and the
+# run left no trace in agent_activities. Keep the tail: the most recent lines are
+# the most useful.
+_ACTIVITY_MAX_CHARS = 2000
+
+
+def _fit_activity(text: str) -> str:
+    """``text`` cut to the gateway's limit, keeping the tail behind a ``…`` marker."""
+    if len(text) <= _ACTIVITY_MAX_CHARS:
+        return text
+    return "…\n" + text[-(_ACTIVITY_MAX_CHARS - 2):]
 
 
 class ActivityFlusher:
@@ -167,9 +177,7 @@ class ActivityFlusher:
         if not self._buf:
             return  # nothing pending → don't open a connection at all
         lines, self._buf = self._buf, []  # swap out atomically (no await between)
-        body = "\n".join(lines)
-        if len(body) > _ACTIVITY_FLUSH_MAX_CHARS:
-            body = "…\n" + body[-_ACTIVITY_FLUSH_MAX_CHARS:]
+        body = _fit_activity("\n".join(lines))
         try:
             await self._client.log_activity(body, task_id=self._task_id, immediate=True)
         except Exception as exc:  # noqa: BLE001 — never let a flush break a run
@@ -313,6 +321,29 @@ class BackendClient:
         except Exception as exc:
             raise BackendUnreachable(self._base_url, str(exc)) from exc
 
+    async def assigned_vps_ip(self) -> str:
+        """The IP of the caller's assigned VPS from ``GET /ml-api/users/profile``.
+
+        ``""`` when the profile names no VPS. Raises BackendUnreachable /
+        BackendAuthFailed — the caller (``sdk.vps_identity``) turns those into
+        "unknown" rather than "not a VPS".
+        """
+        from sdk.config import BE_DEFAULT_URL
+        from sdk.vps_identity import extract_vps_ip
+
+        url = f"{BE_DEFAULT_URL.rstrip('/')}/ml-api/users/profile"
+        headers = {**self._headers, "accept": "*/*", "developer-name": "null", "product": ""}
+        try:
+            async with httpx.AsyncClient(timeout=15.0) as client:
+                resp = await client.get(url, headers=headers)
+            _check_status(resp.status_code, url)
+            data = (resp.json() or {}).get("data") or {}
+        except (BackendAuthFailed, BackendVersionTooOld):
+            raise
+        except Exception as exc:
+            raise BackendUnreachable(url, str(exc)) from exc
+        return extract_vps_ip(data.get("user") or {})
+
     async def profile(self) -> UserProfile:
         """GET {BE}/ml-api/users/profile — the caller's role + department.
 
@@ -1766,7 +1797,7 @@ class BackendClient:
             "developer-name": "null",
             "product": "",
         }
-        body: dict[str, str] = {"activity": str(activity)}
+        body: dict[str, str] = {"activity": _fit_activity(str(activity))}
         tid = str(task_id or "").strip()
         if tid:
             body["taskId"] = tid
@@ -1800,7 +1831,7 @@ class BackendClient:
             return False
         url = f"{ML_GATEWAY_URL.rstrip('/')}/ml-api/agent-activity"
         headers = {**self._headers, "accept": "*/*", "developer-name": "null", "product": ""}
-        body: dict[str, str] = {"activity": str(activity), "agentId": aid}
+        body: dict[str, str] = {"activity": _fit_activity(str(activity)), "agentId": aid}
         tid = str(task_id or "").strip()
         if tid:
             body["taskId"] = tid

devops_bot_sdk-1.6.70/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 ""