devops-bot-sdk 1.4.25__tar.gz → 1.4.26__tar.gz

{devops_bot_sdk-1.4.25 → devops_bot_sdk-1.4.26}/PKG-INFO

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

{devops_bot_sdk-1.4.25 → devops_bot_sdk-1.4.26}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.25 → devops_bot_sdk-1.4.26}/pyproject.toml

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

{devops_bot_sdk-1.4.25 → devops_bot_sdk-1.4.26}/sdk/__init__.py

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

{devops_bot_sdk-1.4.25 → devops_bot_sdk-1.4.26}/sdk/client.py

@@ -36,7 +36,7 @@ from sdk.sse import _check_status, stream_with_reconnect
 
 logger = logging.getLogger(__name__)
 
-SDK_VERSION    = "1.4.25"
+SDK_VERSION    = "1.4.26"
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
 _ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time

{devops_bot_sdk-1.4.25 → devops_bot_sdk-1.4.26}/sdk/ipc/handlers.py

@@ -115,7 +115,11 @@ async def handle_orchestrator_run(
 _PENDING_LOCAL: dict[str, dict] = {}
 
 _POLL_INTERVAL_S = 1.5
-_PLAN_DEADLINE_S = 180.0  # planning + approval gate should be quick
+# How long to wait for backend planning to reach the approval gate before giving
+# up. If this fires the ticket never reached the gate: no WhatsApp is composed and
+# (previously) the ticket was orphaned In Progress. Heavy planning under load can
+# exceed the old fixed 180s, so allow ops to raise it without a code change.
+_PLAN_DEADLINE_S = float(os.getenv("AGENTOS_PLAN_DEADLINE_S", "") or 180.0)
 
 
 # Raw task-description budget (chars). The structured plan already distills the
@@ -354,6 +358,7 @@ async def _run_local_pipeline(
                 "jira_key": payload.get("jira_key"),
                 "summary": payload.get("summary"),
                 "agent_mode": bool(payload.get("agent_mode", True)),
+                "_resume_sessions": payload.get("_resume_sessions") or {},
             }
             await send(Envelope(
                 type=Envelope.TYPE_AWAITING_APPROVAL, thread_id=thread_id,
@@ -428,6 +433,7 @@ async def _code_one_repo(
     thread_id: str,
     task_id: str,
     base: str | None = None,
+    resume_session_id: str | None = None,
 ) -> dict:
     """Clone-if-needed → branch → run claude → open a PR, for ONE repo.
 
@@ -514,10 +520,12 @@ async def _code_one_repo(
         agent_mode=agent_mode, git_managed=bool(branch_info),
     )
 
-    # 3. initial claude run
+    # 3. initial claude run (resume_session_id is set on rate-limit retries so
+    # the model picks up exactly where it was interrupted, skipping re-work).
     result = await local_exec.run_claude_local(
         prompt, repo_path, on_event=_on_event,
         github_token=gh_token, approval_dir=approval_dir,
+        resume_session_id=resume_session_id or None,
     )
 
     # 4. context-window recovery
@@ -714,6 +722,9 @@ async def handle_pipeline_approve(
     # The prompt is built per-repo inside _code_one_repo so its framing matches
     # whether that target is a git repo (branch + PR) or a plain local folder.
     agent_mode = bool(pending.get("agent_mode", True))
+    # Per-repo claude session_ids saved from a previous rate-limit hit — lets
+    # the model resume its interrupted session rather than starting from scratch.
+    resume_sessions: dict[str, str] = pending.get("_resume_sessions") or {}
 
     # Fetch the user's GitHub token from the backend so the local agent can
     # clone/push/open PRs (best-effort — None if no GitHub account connected).
@@ -750,6 +761,7 @@ async def handle_pipeline_approve(
                 pending=pending, gh_token=gh_token,
                 agent_mode=agent_mode, approval_dir=approval_dir,
                 send=send, thread_id=thread_id, task_id=task_id,
+                resume_session_id=resume_sessions.get(tgt["path"]) or None,
             ))
         except Exception as exc:  # noqa: BLE001
             logger.warning("local_run.repo_failed", error=str(exc))
@@ -784,28 +796,37 @@ 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. ──
+    # ── Claude usage-limit hit: DON'T mark Done, DON'T move to Backlog.
+    #    Keep the ticket In Progress and signal the auto-loop to wait for reset.
+    #    Moving to Backlog here would cause the approval gate to re-run on retry
+    #    (15-min timeout → Backlog again → break → next ticket starts). ──
     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")},
+                  "current_step": "Claude usage limit reached — ticket stays In Progress; "
+                                  "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; "
+                f"⚠ Task {task_id}: Claude usage limit reached — staying In Progress; "
                 "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}
+        repo_resume_sessions = {
+            r["repo"]: r["result"]["session_id"]
+            for r in runs if r["result"].get("session_id")
+        }
+        return {
+            "status": "limit_exceeded",
+            "reset_epoch": reset_epoch,
+            "task_id": task_id,
+            "repo_resume_sessions": repo_resume_sessions,
+        }
 
     # ── Notify on WhatsApp if nothing succeeded ──────────────────────────
     if not ok_any:
@@ -1563,6 +1584,22 @@ def _resolve_local_project_path(task: dict, payload: dict) -> str:
 _APPROVAL_POLL_INTERVAL_S = 15.0
 _FIRST_GATE_TIMEOUT_S = 900.0
 _APPROVAL_POLL_TIMEOUT_S = 1200.0
+# First-gate WhatsApp fallback. The backend normally sends the gate-1 approval
+# request (WhatsApp) the moment planning reaches awaiting_approval. If that send
+# fails the approver gets NOTHING and the ticket silently times out to Backlog.
+# As a safety net the SDK re-sends the gate-1 request itself — but only ONCE, and
+# only after this grace window, so a reply that arrives normally never triggers it.
+#
+# NOTE on duplicates: the /mgmt/approve endpoint reflects gate/decision state, not
+# WhatsApp *delivery*, so the SDK cannot tell "backend already messaged" from
+# "backend's message was dropped". A resend therefore risks a duplicate when the
+# gate is simply slow to be answered. Two mitigations: (a) the window is set well
+# past a normal reply time, and (b) true dedup should live in the backend by
+# upserting the (taskId, gateNumber) request rather than sending a fresh WhatsApp.
+# Firing this does NOT reset the 15-min Backlog timeout. Set very high to disable.
+_FIRST_GATE_WA_FALLBACK_S = float(
+    os.getenv("AGENTOS_FIRST_GATE_WA_FALLBACK_S", "") or 300.0
+)
 # Max times a single ticket's session is resumed after a context overflow.
 _MAX_CONTEXT_RESUMES = 3
 # Max times a ticket's session is resumed after hitting the per-response output-token
@@ -1608,20 +1645,35 @@ async def _cooperative_sleep(seconds: float, should_stop: Callable[[], bool] | N
 
 async def _poll_approval(
     client: BackendClient, task_id: str, should_stop: Callable[[], bool] | None = None,
+    *, fallback_notify: Callable[[], Any] | None = None,
+    fallback_after_s: float = 0.0,
 ) -> str:
     """Poll GET /mgmt/approve until approved/rejected, stop, or timeout.
 
     Returns 'approved' | 'rejected' | 'stopped' | 'timeout'. The decision is the
     human's WhatsApp reply, recorded backend-side under approval_log:{task_id}.
     Times out after _FIRST_GATE_TIMEOUT_S (15 min) so the ticket can move to Backlog.
+
+    `fallback_notify`: optional coroutine-returning callable invoked exactly ONCE,
+    the first time `fallback_after_s` seconds have elapsed with no decision — a
+    safety net that (re)sends the approval request when the backend never
+    delivered it. Firing it does NOT reset or extend the 15-min timeout.
     """
     waited = 0.0
+    notified = False
     while waited < _FIRST_GATE_TIMEOUT_S:
         if should_stop is not None and should_stop():
             return "stopped"
         status = await client.approval_status(task_id)
         if status in ("approved", "rejected"):
             return status
+        if (fallback_notify is not None and not notified
+                and waited >= fallback_after_s):
+            notified = True
+            try:
+                await fallback_notify()
+            except Exception:  # noqa: BLE001 — a notify failure must not stop polling
+                pass
         await asyncio.sleep(_APPROVAL_POLL_INTERVAL_S)
         waited += _APPROVAL_POLL_INTERVAL_S
     return "timeout"
@@ -1652,52 +1704,6 @@ async def _poll_fresh_approval(
     return "timeout"
 
 
-async def _background_approval_watcher(
-    client: BackendClient,
-    session_id: str,
-    task_id: str,
-    jira_key: str,
-    thread_id: str,
-    send: Callable,
-    should_stop: Callable[[], bool] | None,
-) -> None:
-    """Poll indefinitely for a late approval on a timed-out gate, then resume.
-
-    Spawned as a fire-and-forget task when the first-gate 15-min timeout fires.
-    When the user approves (via WhatsApp), calls handle_pipeline_approve so the
-    ticket resumes from exactly where it paused. handle_pipeline_approve already
-    calls mark_in_progress, so the Jira status flips In Progress → Backlog →
-    In Progress automatically. Cleans up _PENDING_LOCAL on any terminal outcome.
-    """
-    try:
-        while True:
-            if should_stop is not None and should_stop():
-                return
-            status = await client.approval_status(task_id)
-            if status == "approved":
-                break
-            if status == "rejected":
-                await send(Envelope(
-                    type="step_update", thread_id=thread_id,
-                    data={"current_step": f"{jira_key}: rejected (late approval) — skipped"},
-                ).model_dump())
-                return
-            await asyncio.sleep(_APPROVAL_POLL_INTERVAL_S)
-        # Approval arrived — move back to In Progress and resume execution.
-        await send(Envelope(
-            type="step_update", thread_id=thread_id,
-            data={"current_step": f"{jira_key}: late approval received — resuming from Backlog"},
-        ).model_dump())
-        await handle_pipeline_approve(
-            client,
-            {"session_id": session_id, "decision": "approved", "thread_id": thread_id},
-            send,
-        )
-    except Exception as exc:  # noqa: BLE001
-        logger.warning("background_approval_watcher.failed task=%s err=%s", task_id, exc)
-    finally:
-        _PENDING_LOCAL.pop(session_id, None)
-
 
 async def handle_orchestrate_auto_local_run(
     client: BackendClient, payload: dict, send: Callable,
@@ -1784,38 +1790,89 @@ 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:
-                # 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
-                    # Mark In Progress before any work begins so Jira reflects
-                    # the real state even if the run fails partway through.
+                    # Mark In Progress before any work begins.
                     await client.mark_in_progress(tid)
+
+                    # For retries (attempt > 1): override agent_mode=False so the
+                    # backend skips the WhatsApp gate AND the 15-min Backlog timer.
+                    # Human already approved on attempt 1; a new timer firing mid-run
+                    # would erroneously demote the ticket to Backlog while claude works.
+                    run_payload = (
+                        task_payload if attempt == 1
+                        else {**task_payload, "agent_mode": False}
+                    )
+
                     # Phase 1 — server plans + gates. NO local code/bash runs yet.
-                    await _run_local_pipeline(client, task_payload, send)
+                    await _run_local_pipeline(client, run_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.
+                        # Planning never reached the approval gate — e.g. planning
+                        # timed out, the /orchestrate kickoff errored, or the
+                        # process/network dropped mid-plan. The ticket was marked
+                        # In Progress at the top of this loop, so we MUST move it off
+                        # In Progress here: the 15-min Backlog timer lives inside the
+                        # gate branch below and never runs when the gate isn't
+                        # reached, so without this the ticket is orphaned In Progress
+                        # forever. Backlog matches the other hard-failure paths in
+                        # this loop; note the auto-run only re-fetches "To Do", so a
+                        # Backlog ticket needs a manual move back to To Do (or a new
+                        # run after it is re-queued) to be retried.
+                        await client.log_activity(
+                            f"Task {tid}: planning did not reach the approval gate — "
+                            "returning to Backlog"
+                        )
+                        await client.move_to_backlog(tid)
                         await send(Envelope(
                             type="step_update", thread_id=thread_id,
-                            data={"current_step": f"{jira_key}: skipped (no approval gate reached)"},
+                            data={"current_step": f"{jira_key}: no approval gate reached — "
+                                                  "moved to Backlog (was stuck In Progress)"},
                         ).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:
+                    # ── First-approval gate (agentMode=True, attempt 1 only) ──────
+                    # Skipped on retries — human already approved; re-running the gate
+                    # would time out and advance to the next ticket instead of retrying.
+                    if agent_mode and attempt == 1:
                         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)
+
+                        # Safety net for the gate-1 WhatsApp. The backend sends it
+                        # when planning opens the gate; if that send failed the
+                        # approver would get nothing and the ticket would silently
+                        # time out to Backlog. Re-send it ourselves once, only after
+                        # the grace window, so a healthy backend doesn't duplicate.
+                        _wa_summary = task.get("summary") or jira_key or "task"
+
+                        async def _first_gate_wa_fallback(
+                            tid=tid, jira_key=jira_key, _wa_summary=_wa_summary,
+                        ) -> None:
+                            await send(Envelope(
+                                type="step_update", thread_id=thread_id,
+                                data={"current_step": f"{jira_key}: no approval reply yet — "
+                                                      "re-sending WhatsApp approval request"},
+                            ).model_dump())
+                            await client.notify_whatsapp(
+                                tid,
+                                f"Approval needed for {jira_key or tid}: {_wa_summary} — "
+                                "reply on WhatsApp to approve or reject so the work can start.",
+                                summary=_wa_summary,
+                            )
+
+                        decision = await _poll_approval(
+                            client, tid, should_stop,
+                            fallback_notify=_first_gate_wa_fallback,
+                            fallback_after_s=_FIRST_GATE_WA_FALLBACK_S,
+                        )
+
                         if decision == "stopped":
                             _PENDING_LOCAL.pop(session_id, None)
                             await send(Envelope(
@@ -1824,20 +1881,36 @@ async def handle_orchestrate_auto_local_run(
                                       "processed": processed, "task_count": total},
                             ).model_dump())
                             return
+
                         if decision == "timeout":
-                            # 15 min elapsed — move to Backlog but keep _PENDING_LOCAL
-                            # alive, then spawn a background watcher that polls until
-                            # the user approves and resumes execution automatically.
+                            # 15 min elapsed with no WhatsApp reply.
+                            # Move to Backlog; keep the terminal ALIVE and poll
+                            # indefinitely — no tickets start until approval arrives.
                             await client.move_to_backlog(tid)
                             await send(Envelope(
                                 type="step_update", thread_id=thread_id,
-                                data={"current_step": f"{jira_key}: no approval in 15m — moved to Backlog"
-                                                      " (background watcher will auto-resume on approval)"},
+                                data={"current_step": f"{jira_key}: no approval in 15m — moved to"
+                                                      " Backlog; polling for late approval "
+                                                      "(terminal stays alive)"},
                             ).model_dump())
-                            asyncio.ensure_future(_background_approval_watcher(
-                                client, session_id, tid, jira_key, thread_id, send, should_stop,
-                            ))
-                            break
+                            while True:
+                                if should_stop is not None and should_stop():
+                                    _PENDING_LOCAL.pop(session_id, None)
+                                    return
+                                late = await client.approval_status(tid)
+                                if late in ("approved", "rejected"):
+                                    decision = late
+                                    break
+                                await asyncio.sleep(_APPROVAL_POLL_INTERVAL_S)
+                            if decision == "approved":
+                                # Late approval — move back to In Progress before executing.
+                                await client.mark_in_progress(tid)
+                                await send(Envelope(
+                                    type="step_update", thread_id=thread_id,
+                                    data={"current_step": f"{jira_key}: late approval received — "
+                                                          "resuming (In Progress)"},
+                                ).model_dump())
+
                         if decision != "approved":
                             _PENDING_LOCAL.pop(session_id, None)
                             await send(Envelope(
@@ -1846,48 +1919,50 @@ async def handle_orchestrate_auto_local_run(
                             ).model_dump())
                             break
 
-                    # Phase 2 — run the user's local `claude`, report back.
+                    # ── 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.
+                    # ── Claude usage-limit hit ─────────────────────────────────────
+                    # Move to Backlog (backend 15-min timer fires at that point for
+                    # the first attempt; explicit move covers retries which have no
+                    # timer). Sleep until the window resets, then move back to In
+                    # Progress and resume the same claude session. Terminal stays alive.
                     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. The usage/session limit is ACCOUNT-WIDE, so
-                        # every remaining ticket would hit the same wall and burn its
-                        # own retry budget (up to 6h each). Pause the whole run instead
-                        # of marching on — this ticket and the rest stay in To Do/
-                        # Backlog, and `agentos-auto resume` picks them up after reset.
+                        wait_s = _limit_wait_seconds(outcome.get("reset_epoch"))
+                        # Show the reset time in UK timezone (the VPS clock).
+                        try:
+                            from zoneinfo import ZoneInfo as _ZI
+                            from datetime import datetime as _dt
+                            _uk_tz = _ZI("Europe/London")
+                            _reset_str = _dt.fromtimestamp(
+                                outcome["reset_epoch"], tz=_uk_tz,
+                            ).strftime("%H:%M %Z") if outcome.get("reset_epoch") else f"~{round(wait_s/60)}m"
+                        except Exception:  # noqa: BLE001
+                            _reset_str = f"~{round(wait_s/60)}m"
+                        # Move to Backlog now so Jira reflects the wait state.
+                        await client.move_to_backlog(tid)
                         await send(Envelope(
                             type="step_update", thread_id=thread_id,
-                            data={"current_step": f"{jira_key}: usage limit — max retries reached; "
-                                                  f"pausing run (resume after the window resets)"},
-                        ).model_dump())
-                        await send(Envelope(
-                            type=Envelope.TYPE_DONE, thread_id=thread_id,
-                            data={"mode": "orchestrate-auto-local", "status": "paused",
-                                  "reason": "usage_limit", "processed": processed,
-                                  "task_count": total},
+                            data={"current_step": f"{jira_key}: Claude usage limit — moved to Backlog;"
+                                                  f" resuming at {_reset_str} (attempt {attempt}/"
+                                                  f"{_MAX_LIMIT_RETRIES}); terminal stays alive"},
                         ).model_dump())
-                        return
+                        if not await _cooperative_sleep(wait_s, should_stop):
+                            return  # only exits on explicit stop request
+                        # Limit reset: save per-repo claude session IDs so the model
+                        # resumes exactly where it was interrupted, then loop back to
+                        # mark_in_progress at the top (moves ticket back to In Progress).
+                        task_payload["_resume_sessions"] = (
+                            outcome.get("repo_resume_sessions") or {}
+                        )
+                        if attempt >= _MAX_LIMIT_RETRIES:
+                            # Reset counter so the next window gets a fresh set of retries.
+                            attempt = 0
+                        continue  # re-run this ticket (mark_in_progress at top of loop)
 
                     processed += 1
                     break

devops_bot_sdk-1.4.26/sdk/run_auto.py

@@ -0,0 +1,293 @@
+"""CLI: ``agentos-auto`` — run the full orchestrate-auto pipeline LOCALLY.
+
+Mirrors the old one-shot trigger (``POST /api/v1/orchestrate-auto`` with the
+``co_`` token in the header), but executes on THIS machine: the server plans +
+gates each To Do task, the local ``claude`` writes the code in the project
+directory, and the result is reported back. The only required input is the
+``co_`` token saved by ``agentos configure``.
+
+Commands:
+    agentos-auto                 run every To Do task locally, in the BACKGROUND
+    agentos-auto resume          alias for run — re-fetches remaining To Do tasks
+    agentos-auto stop            ask the running loop to pause after the current task
+    agentos-auto status          show whether the background loop is running / stop pending
+    agentos-auto update          upgrade the SDK to the latest version
+
+Options:
+    --workspace-root DIR         base dir for per-task project folders
+    --foreground, -f             stay attached to the terminal (do not detach)
+    --no-update                  skip the automatic self-update check (or set AGENTOS_NO_UPDATE=1)
+
+Background model: `run`/`resume` detach into a background daemon (double-fork +
+setsid), so closing the terminal (SIGHUP) does NOT stop the loop — it keeps
+running until `agentos-auto stop`. Output goes to ~/.agentos/auto.log and the
+PID to ~/.agentos/auto.pid; only one loop runs at a time. Use `--foreground` to
+run attached (for debugging). Platforms without os.fork fall back to foreground.
+
+Auto-update: on `run`/`resume`, the SDK checks for a newer version and upgrades
+itself (then re-runs on the new code) BEFORE detaching, so non-technical users
+never reinstall.
+
+Stop/resume model: the loop marks each task In Progress/Done on the backend as
+it goes, so the backend task status IS the saved state. `stop` writes a flag the
+running loop checks between tasks (so a stop takes effect after the in-flight
+task finishes); `resume` (or just re-running) clears the flag and continues with
+whatever is still To Do.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import sys
+from pathlib import Path
+
+_AGENTOS_DIR = Path.home() / ".agentos"
+_STOP_FILE = _AGENTOS_DIR / "auto.stop"
+_PID_FILE = _AGENTOS_DIR / "auto.pid"
+_LOG_FILE = _AGENTOS_DIR / "auto.log"
+
+
+def _stop_requested() -> bool:
+    return _STOP_FILE.exists()
+
+
+def _set_stop() -> None:
+    _STOP_FILE.parent.mkdir(parents=True, exist_ok=True)
+    _STOP_FILE.write_text("stop")
+
+
+def _clear_stop() -> None:
+    try:
+        _STOP_FILE.unlink()
+    except FileNotFoundError:
+        pass
+
+
+# ── Background-daemon support ─────────────────────────────────────────────
+# `agentos-auto` must keep running after the terminal is closed and stop ONLY on
+# `agentos-auto stop`. We fully detach from the controlling terminal (double-fork
+# + setsid) so SIGHUP on terminal close no longer reaches the loop.
+
+def _read_pid() -> int | None:
+    try:
+        pid = int(_PID_FILE.read_text().strip())
+    except (FileNotFoundError, ValueError):
+        return None
+    return pid
+
+
+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
+
+
+def _daemon_running() -> int | None:
+    """Return the PID of a live background loop, else None (clearing a stale file)."""
+    pid = _read_pid()
+    if pid is None:
+        return None
+    if _pid_alive(pid):
+        return pid
+    # Stale PID file left by a crashed/killed daemon — clean it up.
+    try:
+        _PID_FILE.unlink()
+    except FileNotFoundError:
+        pass
+    return None
+
+
+def _daemonize() -> bool:
+    """Detach the current process from the terminal (POSIX double-fork).
+
+    Returns True in the surviving daemon child; the two intermediate parents call
+    os._exit() and never return. stdout/stderr are redirected to _LOG_FILE and a
+    PID file is written so `stop`/`status` can find the loop. Returns False (stays
+    in the foreground) on platforms without os.fork (e.g. Windows).
+    """
+    if not hasattr(os, "fork"):
+        return False  # caller falls back to foreground
+
+    _AGENTOS_DIR.mkdir(parents=True, exist_ok=True)
+
+    # First fork: let the shell reap the parent and return the prompt.
+    if os.fork() > 0:
+        os._exit(0)
+    os.setsid()  # new session leader → drop the controlling terminal
+    # Second fork: guarantee the daemon can never reacquire a controlling terminal.
+    if os.fork() > 0:
+        os._exit(0)
+
+    # Redirect stdio: stdin ← /dev/null, stdout/stderr → append to the log file.
+    sys.stdout.flush()
+    sys.stderr.flush()
+    devnull = os.open(os.devnull, os.O_RDONLY)
+    logfd = os.open(_LOG_FILE, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o644)
+    os.dup2(devnull, sys.stdin.fileno())
+    os.dup2(logfd, sys.stdout.fileno())
+    os.dup2(logfd, sys.stderr.fileno())
+    os.close(devnull)
+    os.close(logfd)
+
+    _PID_FILE.write_text(str(os.getpid()))
+    return True
+
+
+def _parse_workspace_root(argv: list[str]) -> str | None:
+    if "--workspace-root" in argv:
+        i = argv.index("--workspace-root")
+        try:
+            return argv[i + 1]
+        except IndexError:
+            print("error: --workspace-root needs a directory argument")
+            sys.exit(1)
+    return None
+
+
+async def _send(env: dict) -> None:
+    etype = env.get("type", "")
+    data = env.get("data", {}) or {}
+    if etype == "pipeline_started":
+        print(f"\n▶ orchestrate-auto (local) — {data.get('task_count', 0)} task(s)\n")
+    elif etype == "step_update":
+        step = data.get("current_step", "")
+        pp = data.get("project_path")
+        print(f"  • {step}" + (f"   [{pp}]" if pp else ""))
+    elif etype == "awaiting_approval":
+        print(f"  ⏸ approval gate: {data.get('summary', data.get('jira_key', ''))}")
+    elif etype == "error":
+        print(f"  ✗ {data.get('message') or data.get('code') or data}")
+    elif etype == "done":
+        status = data.get("status", "")
+        if status == "paused":
+            print(f"\n⏸ paused after {data.get('processed', 0)}/{data.get('task_count', 0)} "
+                  f"task(s). run `agentos-auto resume` to continue.\n")
+        else:
+            print(f"\n✓ done — {json.dumps(data)[:400]}\n")
+    else:
+        print(f"  [{etype}] {json.dumps(data)[:200]}")
+
+
+def _run_loop(workspace_root: str | None) -> None:
+    from sdk import local_exec
+    from sdk.client import BackendClient
+    from sdk.ipc import handlers
+
+    if not local_exec.is_available():
+        print("error: the `claude` CLI is not installed/authenticated on this machine.")
+        print("       install it and run `claude setup-token`, then retry.")
+        sys.exit(1)
+
+    try:
+        client = BackendClient.from_config()  # co_ token + server URL from ~/.agentos/config.toml
+    except Exception as exc:  # noqa: BLE001
+        print(f"error: SDK not configured ({exc}). run `agentos configure` first.")
+        sys.exit(1)
+
+    payload: dict = {"thread_id": "agentos-auto-cli"}
+    if workspace_root:
+        payload["workspace_root"] = workspace_root
+
+    _clear_stop()  # a fresh run/resume clears any stale stop flag
+    try:
+        asyncio.run(
+            handlers.handle_orchestrate_auto_local_run(
+                client, payload, _send, should_stop=_stop_requested,
+            )
+        )
+    except KeyboardInterrupt:
+        _set_stop()
+        print("\n⏸ interrupted — stop flag set. run `agentos-auto resume` to continue.")
+    finally:
+        # Whether the loop finished, paused, or crashed, drop our PID file so
+        # `status` doesn't report a dead daemon as running.
+        if _read_pid() == os.getpid():
+            try:
+                _PID_FILE.unlink()
+            except FileNotFoundError:
+                pass
+
+
+def main() -> None:
+    argv = sys.argv[1:]
+    cmd = argv[0] if argv and not argv[0].startswith("-") else "run"
+
+    if cmd == "update":
+        from sdk.updater import auto_update
+        updated, cur, latest = auto_update(quiet=False)
+        if not updated:
+            print(f"already up to date (v{cur})" if latest else f"v{cur} (could not reach PyPI)")
+        return
+
+    if cmd == "stop":
+        _set_stop()
+        pid = _daemon_running()
+        if pid:
+            print(f"stop requested — the background loop (pid {pid}) will pause after "
+                  "the current task, then exit.")
+        else:
+            print("stop requested — a running `agentos-auto` will pause after the current task.")
+        return
+
+    if cmd == "status":
+        pid = _daemon_running()
+        if pid:
+            print(f"background loop: running (pid {pid})")
+            print(f"logs: {_LOG_FILE}")
+        else:
+            print("background loop: not running")
+        print("stop pending: yes" if _stop_requested() else "stop pending: no")
+        return
+
+    if cmd in ("run", "resume"):
+        # Refuse to start a second loop — one background daemon owns the To Do queue.
+        pid = _daemon_running()
+        if pid:
+            print(f"agentos-auto is already running in the background (pid {pid}).")
+            print(f"  logs:   {_LOG_FILE}")
+            print("  stop:   agentos-auto stop")
+            return
+
+        # Keep non-technical users current: self-update, then re-run on the new
+        # code. Runs in the FOREGROUND (before detaching) so the user sees update
+        # output. Skipped with --no-update or AGENTOS_NO_UPDATE=1.
+        if "--no-update" not in argv:
+            from sdk.updater import auto_update_and_reexec
+            auto_update_and_reexec("sdk.run_auto", sys.argv[1:])
+
+        workspace_root = _parse_workspace_root(argv)
+
+        # Background by default: detach so closing the terminal (SIGHUP) can't kill
+        # the loop — it runs until `agentos-auto stop`. `--foreground`/`-f` keeps it
+        # attached (useful for debugging). On platforms without fork we stay attached.
+        foreground = "--foreground" in argv or "-f" in argv
+        if not foreground and hasattr(os, "fork"):
+            print("▶ agentos-auto started in the background — it keeps running after you "
+                  "close this terminal.")
+            print(f"  logs:   {_LOG_FILE}")
+            print("  status: agentos-auto status")
+            print("  stop:   agentos-auto stop")
+        if not foreground and _daemonize():
+            _run_loop(workspace_root)  # only the detached daemon child reaches here
+            return
+        if not foreground:
+            print("note: background mode unavailable on this platform — running in the "
+                  "foreground. Keep this terminal open.")
+        else:
+            # Foreground run still records a PID so stop/status can find it.
+            _AGENTOS_DIR.mkdir(parents=True, exist_ok=True)
+            _PID_FILE.write_text(str(os.getpid()))
+        _run_loop(workspace_root)
+        return
+
+    print(f"unknown command '{cmd}'. use: run | resume | stop | status | update")
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

devops_bot_sdk-1.4.25/sdk/run_auto.py

@@ -1,155 +0,0 @@
-"""CLI: ``agentos-auto`` — run the full orchestrate-auto pipeline LOCALLY.
-
-Mirrors the old one-shot trigger (``POST /api/v1/orchestrate-auto`` with the
-``co_`` token in the header), but executes on THIS machine: the server plans +
-gates each To Do task, the local ``claude`` writes the code in the project
-directory, and the result is reported back. The only required input is the
-``co_`` token saved by ``agentos configure``.
-
-Commands:
-    agentos-auto                 run every To Do task locally (start / resume)
-    agentos-auto resume          alias for run — re-fetches remaining To Do tasks
-    agentos-auto stop            ask a running loop to pause after the current task
-    agentos-auto status          show whether a stop is pending
-    agentos-auto update          upgrade the SDK to the latest version
-
-Options:
-    --workspace-root DIR         base dir for per-task project folders
-    --no-update                  skip the automatic self-update check (or set AGENTOS_NO_UPDATE=1)
-
-Auto-update: on `run`/`resume`, the SDK checks for a newer version and upgrades
-itself (then re-runs on the new code), so non-technical users never reinstall.
-
-Stop/resume model: the loop marks each task In Progress/Done on the backend as
-it goes, so the backend task status IS the saved state. `stop` writes a flag the
-running loop checks between tasks; `resume` (or just re-running) clears the flag
-and continues with whatever is still To Do.
-"""
-from __future__ import annotations
-
-import asyncio
-import json
-import sys
-from pathlib import Path
-
-_STOP_FILE = Path.home() / ".agentos" / "auto.stop"
-
-
-def _stop_requested() -> bool:
-    return _STOP_FILE.exists()
-
-
-def _set_stop() -> None:
-    _STOP_FILE.parent.mkdir(parents=True, exist_ok=True)
-    _STOP_FILE.write_text("stop")
-
-
-def _clear_stop() -> None:
-    try:
-        _STOP_FILE.unlink()
-    except FileNotFoundError:
-        pass
-
-
-def _parse_workspace_root(argv: list[str]) -> str | None:
-    if "--workspace-root" in argv:
-        i = argv.index("--workspace-root")
-        try:
-            return argv[i + 1]
-        except IndexError:
-            print("error: --workspace-root needs a directory argument")
-            sys.exit(1)
-    return None
-
-
-async def _send(env: dict) -> None:
-    etype = env.get("type", "")
-    data = env.get("data", {}) or {}
-    if etype == "pipeline_started":
-        print(f"\n▶ orchestrate-auto (local) — {data.get('task_count', 0)} task(s)\n")
-    elif etype == "step_update":
-        step = data.get("current_step", "")
-        pp = data.get("project_path")
-        print(f"  • {step}" + (f"   [{pp}]" if pp else ""))
-    elif etype == "awaiting_approval":
-        print(f"  ⏸ approval gate: {data.get('summary', data.get('jira_key', ''))}")
-    elif etype == "error":
-        print(f"  ✗ {data.get('message') or data.get('code') or data}")
-    elif etype == "done":
-        status = data.get("status", "")
-        if status == "paused":
-            print(f"\n⏸ paused after {data.get('processed', 0)}/{data.get('task_count', 0)} "
-                  f"task(s). run `agentos-auto resume` to continue.\n")
-        else:
-            print(f"\n✓ done — {json.dumps(data)[:400]}\n")
-    else:
-        print(f"  [{etype}] {json.dumps(data)[:200]}")
-
-
-def _run_loop(workspace_root: str | None) -> None:
-    from sdk import local_exec
-    from sdk.client import BackendClient
-    from sdk.ipc import handlers
-
-    if not local_exec.is_available():
-        print("error: the `claude` CLI is not installed/authenticated on this machine.")
-        print("       install it and run `claude setup-token`, then retry.")
-        sys.exit(1)
-
-    try:
-        client = BackendClient.from_config()  # co_ token + server URL from ~/.agentos/config.toml
-    except Exception as exc:  # noqa: BLE001
-        print(f"error: SDK not configured ({exc}). run `agentos configure` first.")
-        sys.exit(1)
-
-    payload: dict = {"thread_id": "agentos-auto-cli"}
-    if workspace_root:
-        payload["workspace_root"] = workspace_root
-
-    _clear_stop()  # a fresh run/resume clears any stale stop flag
-    try:
-        asyncio.run(
-            handlers.handle_orchestrate_auto_local_run(
-                client, payload, _send, should_stop=_stop_requested,
-            )
-        )
-    except KeyboardInterrupt:
-        _set_stop()
-        print("\n⏸ interrupted — stop flag set. run `agentos-auto resume` to continue.")
-
-
-def main() -> None:
-    argv = sys.argv[1:]
-    cmd = argv[0] if argv and not argv[0].startswith("-") else "run"
-
-    if cmd == "update":
-        from sdk.updater import auto_update
-        updated, cur, latest = auto_update(quiet=False)
-        if not updated:
-            print(f"already up to date (v{cur})" if latest else f"v{cur} (could not reach PyPI)")
-        return
-
-    if cmd == "stop":
-        _set_stop()
-        print("stop requested — a running `agentos-auto` will pause after the current task.")
-        return
-
-    if cmd == "status":
-        print("stop pending: yes" if _stop_requested() else "stop pending: no")
-        return
-
-    if cmd in ("run", "resume"):
-        # Keep non-technical users current: self-update, then re-run on the new
-        # code. Skipped with --no-update or AGENTOS_NO_UPDATE=1.
-        if "--no-update" not in argv:
-            from sdk.updater import auto_update_and_reexec
-            auto_update_and_reexec("sdk.run_auto", sys.argv[1:])
-        _run_loop(_parse_workspace_root(argv))
-        return
-
-    print(f"unknown command '{cmd}'. use: run | resume | stop | status | update")
-    sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()