devops-bot-sdk 1.6.19__tar.gz → 1.6.25__tar.gz

{devops_bot_sdk-1.6.19 → devops_bot_sdk-1.6.25}/PKG-INFO

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

{devops_bot_sdk-1.6.19 → devops_bot_sdk-1.6.25}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.19 → devops_bot_sdk-1.6.25}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -17,13 +17,18 @@ sdk/exceptions.py
 sdk/formats.py
 sdk/git_ops.py
 sdk/github_ingest.py
+sdk/graph_recon.py
 sdk/graphify.py
+sdk/intake.py
 sdk/local_exec.py
+sdk/phase_timer.py
+sdk/plan_run.py
 sdk/platform_compat.py
 sdk/py.typed
 sdk/run_auto.py
 sdk/scheduler.py
 sdk/sse.py
+sdk/task_file.py
 sdk/test.py
 sdk/test_pipeline.py
 sdk/ticket_fields.py
@@ -88,6 +93,7 @@ sdk/ui/session.py
 sdk/ui/setup_manager.py
 sdk/ui/static/agents.html
 sdk/ui/static/app.js
+sdk/ui/static/chat.html
 sdk/ui/static/custom-agents.html
 sdk/ui/static/default-agents.html
 sdk/ui/static/index.html
@@ -98,6 +104,7 @@ sdk/ui/static/setup.html
 sdk/ui/static/styles.css
 sdk/ui/static/tickets.html
 tests/test_agent_activity.py
+tests/test_agent_activity_tracking.py
 tests/test_agent_chat_features.py
 tests/test_agent_listing.py
 tests/test_agent_prompt_async.py
@@ -113,19 +120,32 @@ tests/test_config_token_diagnostics.py
 tests/test_configure_token_owner.py
 tests/test_console_encoding.py
 tests/test_departments.py
+tests/test_epic_decompose_run.py
 tests/test_epic_inherited_agent_id.py
+tests/test_epic_session_isolation.py
 tests/test_formats.py
 tests/test_git_action.py
 tests/test_github_ingest.py
+tests/test_graph_recon.py
+tests/test_graphify_build.py
+tests/test_graphify_hook_install.py
 tests/test_health.py
+tests/test_intake_plan_review.py
 tests/test_otp_login.py
+tests/test_phase_timer.py
+tests/test_plan_new_command.py
+tests/test_plan_run_activity.py
+tests/test_recon_session_isolation.py
 tests/test_run_auto_agent_only.py
 tests/test_run_outputs.py
 tests/test_schedule_api.py
 tests/test_scheduler.py
 tests/test_service_token_warning.py
+tests/test_task_file_and_plan_run.py
+tests/test_task_file_format_doc.py
 tests/test_ticket_fields.py
 tests/test_ticket_run_resolve_by_id.py
+tests/test_ticket_speed_fixes.py
 tests/test_update_timer.py
 tests/test_updater_extras.py
 tests/test_vps_health.py

{devops_bot_sdk-1.6.19 → devops_bot_sdk-1.6.25}/sdk/__init__.py

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

@@ -114,6 +114,22 @@ def _stop_requested() -> bool:
     return _STOP_FILE.exists()
 
 
+def _auto_loop_owns_queue() -> bool:
+    """True when an `agentos-auto` loop is live and processing the ticket queue.
+
+    Reuses run_auto's own liveness check, which already distinguishes a running
+    daemon from a stale PID file left by a crash. Best-effort: if we cannot tell,
+    say False — refusing to dispatch on an unreadable PID file would silently
+    disable ticket-label agents, which is worse than the overlap we are avoiding.
+    """
+    try:
+        from sdk import run_auto
+
+        return run_auto._daemon_running() is not None
+    except Exception:  # noqa: BLE001
+        return False
+
+
 def _set_stop() -> None:
     _AGENTOS_DIR.mkdir(parents=True, exist_ok=True)
     _STOP_FILE.write_text("stop")
@@ -585,11 +601,30 @@ class AgentDaemon:
         `_TICKET_POLL_INTERVAL_S` between iterations. Keeps an in-memory set
         of already-dispatched task ids so a task is never re-fired on a later
         poll within this daemon's lifetime.
+
+        DEFERS while an `agentos-auto` loop owns the queue. That loop processes
+        tickets strictly sequentially, oldest `createdAt` first; dispatching from
+        here concurrently (`asyncio.create_task` below) would run a ticket
+        alongside it and out of order — two agents editing the same working
+        directory at once, and a queue that no longer honours creation time.
+        Deferring costs at most one poll interval: the ticket stays To Do and is
+        picked up on a later tick, or by the auto-loop itself.
         """
         dispatched_task_ids: set[str] = set()
         ticket_agents = [m for m in self._manifests if m.trigger.type == "ticket_label"]
+        deferring = False
 
         while not _stop_requested():
+            if ticket_agents and _auto_loop_owns_queue():
+                if not deferring:
+                    logger.info("agentd.watch_tickets_deferred reason=auto_loop_running")
+                    deferring = True
+                await asyncio.sleep(_TICKET_POLL_INTERVAL_S)
+                continue
+            if deferring:
+                logger.info("agentd.watch_tickets_resumed")
+                deferring = False
+
             if ticket_agents:
                 try:
                     tasks = await self.client.list_todo_tasks_raw()
@@ -611,7 +646,7 @@ class AgentDaemon:
 
             await asyncio.sleep(_TICKET_POLL_INTERVAL_S)
 
-    async def run_forever(self) -> None:
+    async def run_forever(self) -> None:  # noqa: D401 — see class docstring
         """Load + schedule agents, start the cron scheduler, then watch tickets
         until stopped. Shuts the scheduler down cleanly on the way out."""
         await self.load_and_schedule()

devops_bot_sdk-1.6.25/sdk/agents/activity.py

@@ -0,0 +1,250 @@
+"""Agent-activity reporting — the ONE place a custom / department agent run is
+recorded, for both sinks:
+
+  * the LOCAL usage ledger (``sdk.agents.usage`` → ``~/.agentos/usage.jsonl``),
+    which backs ``GET /api/ui/agents/usage`` and, through it, the AI backend
+    report's "VPS Agent Logs" section, and
+  * the PLATFORM activity feed — ``POST {ML_GATEWAY}/ml-api/agent-activity``
+    with ``{activity, agentId}``, which the ML backend writes into the Postgres
+    ``agent_activities`` table (docs/DATABASE_SCHEMA.md #3: ``user_id``,
+    ``activity``, ``agent_id``) and the AI backend reads back RBAC-scoped for
+    reporting + chat.
+
+Every VPS-side agent run goes through here no matter how it was triggered — the
+control panel (chat / run / run-on-ticket), an ``agentd`` cron schedule, an
+``agentd`` ticket-label trigger, the CLI, or the desktop IPC bridge. Before this
+module only the control-panel paths emitted, so scheduled and ticket-triggered
+runs never reached ``agent_activities``.
+
+``agent_activities.agent_id`` is an FK onto ``agents.id``, so only agents that
+exist in the BACKEND emit — ``BackendClient.resolve_agent_id`` returns None for
+a local-only manifest and the emit is skipped (the local ledger still records
+it). Both custom and department-default agents resolve, so both are tracked.
+
+Best-effort throughout: nothing in here raises into a run.
+"""
+from __future__ import annotations
+
+import logging
+import os
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:  # pragma: no cover — typing only
+    from sdk.client import BackendClient
+
+logger = logging.getLogger("sdk.agents.activity")
+
+# How a run reached us → the verb that opens the activity line. Keep these short:
+# the feed is rendered as one line per row in reports and in chat answers.
+_VERB = {
+    "chat": "Chatted with",
+    "run": "Ran",
+    "run-ticket": "Ran",
+    "scheduled": "Ran (schedule)",
+    "ticket_label": "Ran (ticket trigger)",
+    "cli": "Ran (cli)",
+}
+
+
+def describe(name: str, kind: str, result: dict | None, duration_s: float = 0.0,
+             detail: str = "") -> str:
+    """The human-readable ``activity`` string stored in ``agent_activities``."""
+    res = result or {}
+    verb = _VERB.get(kind, "Ran")
+    status = "ok" if res.get("ok") else "error"
+    line = f"{verb} agent '{name}' — {status}"
+    if duration_s:
+        line += f" ({round(float(duration_s), 1)}s)"
+    err = str(res.get("error") or "").strip()
+    if status == "error" and err:
+        line += f": {err[:200]}"
+    if detail:
+        line += f" — {detail}"
+    return line
+
+
+# ── Run-log lines → the activity event ────────────────────────────────────
+# Every line `run_log.log_line` writes to a run's Markdown file is also noted
+# here, so the activity event a run produces carries what the run actually DID
+# rather than only that it finished. The buffer exists because the alternative —
+# a webhook POST per line — is exactly the pattern that saturated the shared
+# Postgres pool and led to `client.ActivityFlusher` (see sdk/client.py:100).
+#
+# Two sinks, matching that design:
+#   * a ticket-scoped `ActivityFlusher`, when one is active (the ticket loop sets
+#     it) — `record()` does no I/O and the flusher coalesces into one POST every
+#     3-5 minutes;
+#   * otherwise this per-run buffer, drained by `record_run` into the ONE
+#     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
+
+
+def note(bucket: str, text: str) -> None:
+    """Record one run-log line against ``bucket`` (a run's output folder name).
+
+    Never raises and never does I/O: this is called from `run_log.log_line`, on
+    the hot path of a streaming engine run.
+    """
+    line = str(text or "").strip()
+    if not line:
+        return
+    try:
+        from sdk.client import _ACTIVE_ACTIVITY_FLUSHER
+        flusher = _ACTIVE_ACTIVITY_FLUSHER.get()
+    except Exception:  # noqa: BLE001
+        flusher = None
+    if flusher is not None:
+        flusher.record(line)
+        return
+    buf = _LINE_BUF.setdefault(str(bucket), [])
+    buf.append(line)
+    if len(buf) > _LINE_BUF_MAX_LINES:
+        del buf[: len(buf) - _LINE_BUF_MAX_LINES]
+
+
+def drain(bucket: str) -> list[str]:
+    """Take and clear the lines noted for ``bucket``."""
+    return _LINE_BUF.pop(str(bucket), [])
+
+
+def _lines_block(lines: list[str]) -> str:
+    """The recorded lines as one bounded block, newest-biased."""
+    if not lines:
+        return ""
+    out: list[str] = []
+    total = 0
+    for line in reversed(lines):                  # newest first, then re-reverse
+        if total + len(line) + 1 > _LINE_BUF_MAX_CHARS:
+            break
+        out.append(line)
+        total += len(line) + 1
+    return "\n".join(reversed(out))
+
+
+def mirror_to_auto_log(name: str, kind: str, result: dict | None,
+                       duration_s: float = 0.0, *, detail: str = "",
+                       task_id: str = "") -> bool:
+    """Append a one-line summary of an agent run to ``~/.agentos/auto.log``.
+
+    `agentos-auto logs [-f]` tails that file and nothing else, so before this an
+    agent run — including a ticket-triggered one — was invisible there: it landed
+    in `agent_outputs/<agent>/*.md` and `usage.jsonl`, and an operator watching
+    the log saw the ticket loop go quiet with no explanation. Mirroring here
+    rather than at each trigger site is deliberate: every VPS-side run already
+    funnels through `record_run`, so one append covers the panel, the CLI, an
+    agentd cron schedule, an agentd ticket-label trigger and the IPC bridge.
+
+    A summary, not a transcript — the transcript stays in `agent_outputs/`, and
+    the pointer below is how you get from one to the other. Best-effort and
+    silent on failure: a log line must never break a run. Set
+    ``AGENTOS_NO_AGENT_LOG_MIRROR=1`` to turn it off.
+    """
+    if os.getenv("AGENTOS_NO_AGENT_LOG_MIRROR"):
+        return False
+    try:
+        from sdk.agents.run_log import agent_dir
+        from sdk.run_auto import _LOG_FILE
+    except Exception:  # noqa: BLE001 — never break a run over a log line
+        return False
+
+    res = result or {}
+    stamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%SZ")
+    line = f"  • [{stamp}] {describe(name, kind, res, duration_s, detail)}"
+    # agentd passes the ticket BOTH as `detail` ("task T1") and as `task_id`, so an
+    # unconditional suffix renders "… — task T1 · task T1".
+    if task_id and f"task {task_id}" not in line:
+        line += f" · task {task_id}"
+    try:
+        where = agent_dir(name)
+    except Exception:  # noqa: BLE001
+        where = None
+    if where:
+        line += f"\n    ↳ transcript: {where}"
+
+    try:
+        _LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        with _LOG_FILE.open("a", encoding="utf-8") as fh:
+            fh.write(line + "\n")
+        return True
+    except Exception as exc:  # noqa: BLE001
+        logger.debug("auto.log mirror failed agent=%s err=%s", name, exc)
+        return False
+
+
+async def emit(name: str, kind: str, result: dict | None, duration_s: float = 0.0,
+               *, client: "BackendClient | None" = None, detail: str = "",
+               task_id: str = "", lines: list[str] | None = None) -> bool:
+    """Emit ONE ``{activity, agentId[, taskId]}`` event for a finished agent run.
+
+    Returns True when the webhook accepted it, False otherwise (unknown agent,
+    no token, backend down) — never raises.
+
+    ``task_id`` attributes a ticket-triggered run to its ticket. A scheduled or
+    CLI run has no ticket and omits it.
+    """
+    try:
+        if client is None:
+            from sdk.client import BackendClient
+            client = BackendClient.from_config()
+        agent_id = await client.resolve_agent_id(name)
+        if not agent_id:
+            # Local-only agent → not tracked. This used to return in silence,
+            # which is why "the webhook never fires" had no diagnosable cause:
+            # the run succeeded, the ledger recorded it, and the only missing
+            # thing was a Postgres row nobody could tie back to a decision.
+            # `resolve_agent_id` logs WHY (unreachable listing vs genuinely
+            # absent); this says what it cost.
+            logger.warning(
+                "agent %r has no backend agentId — skipping the agent-activity "
+                "webhook, so this run will not appear in agent_activities. It is "
+                "still in the local ledger and in agent_outputs/.", name)
+            return False
+        activity_text = describe(name, kind, result, duration_s, detail)
+        block = _lines_block(lines or [])
+        if block:
+            activity_text += "\n" + block
+        return await client.log_agent_activity(activity_text, agent_id, task_id=task_id)
+    except Exception as exc:  # noqa: BLE001 — activity emit must never break a run
+        logger.warning("activity emit failed agent=%s err=%s", name, exc)
+        return False
+
+
+async def record_run(name: str, kind: str, result: dict | None, duration_s: float = 0.0,
+                     *, client: "BackendClient | None" = None, detail: str = "",
+                     task_id: str = "") -> None:
+    """Record a finished run to BOTH sinks: local ledger, then platform feed.
+
+    The ledger write happens first and independently of the webhook, so a
+    backend outage still leaves per-agent utilisation on the VPS (which is what
+    ``/api/ui/agents/usage`` and the report's "VPS Agent Logs" read).
+    """
+    res: dict[str, Any] = result or {}
+    try:
+        from sdk.agents import usage as usage_mod
+        usage_mod.record(
+            name,
+            kind=kind,
+            duration_s=duration_s,
+            input_tokens=res.get("input_tokens", 0) or 0,
+            output_tokens=res.get("output_tokens", 0) or 0,
+            cost_usd=res.get("cost_usd", 0.0) or 0.0,
+            ok=bool(res.get("ok")),
+        )
+    except Exception as exc:  # noqa: BLE001 — ledger write must never break a run
+        logger.debug("activity ledger write failed agent=%s err=%s", name, exc)
+
+    mirror_to_auto_log(name, kind, res, duration_s, detail=detail, task_id=task_id)
+
+    # Whatever this run's log lines recorded travels with the ONE event, so the
+    # activity feed shows what the agent did, not just that it finished.
+    try:
+        from sdk.agents.run_log import _folder_name
+        lines = drain(_folder_name(name))
+    except Exception:  # noqa: BLE001
+        lines = []
+
+    await emit(name, kind, res, duration_s, client=client, detail=detail,
+               task_id=task_id, lines=lines)

{devops_bot_sdk-1.6.19 → devops_bot_sdk-1.6.25}/sdk/agents/run_log.py

@@ -175,7 +175,13 @@ def start_run(agent_name: str, *, scope: str = "custom", engine: str = "",
 
 
 def log_line(path: Path | None, text: str) -> None:
-    """Append a raw line to the activity block (best-effort, no-op if path is None)."""
+    """Append a raw line to the activity block (best-effort, no-op if path is None).
+
+    The line is also noted for the run's activity event (``activity.note``), so
+    what the run did reaches the platform feed and not merely the fact that it
+    finished. That is a buffer append with no I/O — a POST per line is what
+    saturated the shared Postgres pool and is why the coalescing exists.
+    """
     if not path:
         return
     try:
@@ -183,6 +189,11 @@ def log_line(path: Path | None, text: str) -> None:
             fh.write(f"[{_now()}] {text}\n")
     except Exception as exc:  # noqa: BLE001
         logger.debug("run_log.line failed: %s", exc)
+    try:
+        from sdk.agents import activity
+        activity.note(path.parent.name, str(text))
+    except Exception as exc:  # noqa: BLE001 — a feed note must never break a run
+        logger.debug("run_log.note failed: %s", exc)
 
 
 def log_event(path: Path | None, event: dict) -> None:

{devops_bot_sdk-1.6.19 → devops_bot_sdk-1.6.25}/sdk/cli.py

@@ -12,6 +12,14 @@ Command surface:
         Store (or replace) the co_<uuid>_<hex> backend token. See
         sdk.config.configure_cli.
 
+    agentos chat [--product-id ID] [--pv-id ID] [--no-autorun]
+        Describe work in plain language; the backend asks the follow-up
+        questions until it has a goal, scope, acceptance criteria,
+        constraints, owning department and priority, then builds the plan,
+        creates the ticket(s) and wakes the auto-loop. The new ticket still
+        runs in createdAt order behind anything already queued.
+        See sdk.intake.chat_cli.
+
     agentos agent new
         Interactive wizard (input() prompts) — name, description, engine
         (default "claude_code"), trigger type (schedule/ticket_label/manual/
@@ -86,6 +94,15 @@ def main() -> None:
         configure_cli(rotate="--rotate" in sys.argv)
         return
 
+    if noun == "chat":
+        from sdk.intake import IntakeError, chat_cli
+        try:
+            chat_cli(rest)
+        except IntakeError as exc:
+            print(f"error: {exc}")
+            sys.exit(1)
+        return
+
     if noun == "agent":
         _agent_command(rest)
         return
@@ -111,9 +128,10 @@ def main() -> None:
 
 
 def _print_usage() -> None:
-    print("usage: agentos <configure|agent|integration|default-agents|agentd|github> ...")
+    print("usage: agentos <configure|chat|agent|integration|default-agents|agentd|github> ...")
     print()
     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>")
     print("  agentos agent <set-key NAME KEY[=VALUE]…|keys NAME|rm-key NAME KEY…>   # persistent API keys (custom agents)")
     print("  agentos integration <add PATH|test NAME|list|rm NAME>")