devops-bot-sdk 1.4.1__tar.gz → 1.4.3__tar.gz

{devops_bot_sdk-1.4.1 → devops_bot_sdk-1.4.3}/PKG-INFO

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

{devops_bot_sdk-1.4.1 → devops_bot_sdk-1.4.3}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.1 → devops_bot_sdk-1.4.3}/pyproject.toml

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

{devops_bot_sdk-1.4.1 → devops_bot_sdk-1.4.3}/sdk/__init__.py

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

{devops_bot_sdk-1.4.1 → devops_bot_sdk-1.4.3}/sdk/client.py

@@ -36,7 +36,7 @@ from sdk.sse import _check_status, stream_with_reconnect
 
 logger = logging.getLogger(__name__)
 
-SDK_VERSION    = "1.4.1"
+SDK_VERSION    = "1.4.3"
 _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.1 → devops_bot_sdk-1.4.3}/sdk/git_ops.py

@@ -9,11 +9,14 @@ names). Everything here is best-effort and never raises into the run.
 from __future__ import annotations
 
 import asyncio
+import logging
 import os
 import re
 import shutil
 from pathlib import Path
 
+logger = logging.getLogger(__name__)
+
 
 def slugify(text: str | None, max_len: int = 40) -> str:
     s = re.sub(r"[^a-z0-9]+", "-", (text or "").lower()).strip("-")
@@ -92,13 +95,72 @@ async def start_branch(
     return {"branch": branch, "base": base}
 
 
+async def _remote_owner_repo(path: str, env: dict) -> tuple[str, str] | None:
+    """Parse origin's URL into (owner, repo). Handles https and ssh forms."""
+    rc, out, _ = await _run(["git", "remote", "get-url", "origin"], path, env)
+    if rc != 0 or not out:
+        return None
+    m = re.search(r"github\.com[:/]+([^/]+)/(.+?)(?:\.git)?/?$", out.strip())
+    if not m:
+        return None
+    return m.group(1), m.group(2)
+
+
+async def _create_pr_via_api(
+    owner: str, repo: str, base: str, head: str, title: str, body: str, token: str,
+) -> str | None:
+    """Open a PR through the GitHub REST API (no `gh` CLI needed).
+
+    The token from /ml-api/github/token carries `repo` scope, so it can both push
+    and open PRs. Returns the PR html_url, or the existing open PR's url when one
+    already exists for this head (422). Returns None (and logs) on any other error.
+    """
+    import httpx
+
+    api = f"https://api.github.com/repos/{owner}/{repo}/pulls"
+    headers = {
+        "Authorization": f"token {token}",
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as c:
+            resp = await c.post(
+                api, headers=headers,
+                json={"title": title, "head": head, "base": base, "body": body},
+            )
+        if resp.status_code == 201:
+            return resp.json().get("html_url")
+        # 422 = a PR already exists for this head (or validation issue). Try to
+        # surface the existing open PR rather than reporting "no PR".
+        if resp.status_code == 422:
+            async with httpx.AsyncClient(timeout=30.0) as c:
+                r2 = await c.get(
+                    api, headers=headers,
+                    params={"head": f"{owner}:{head}", "state": "open"},
+                )
+            if r2.status_code == 200 and r2.json():
+                return r2.json()[0].get("html_url")
+        logger.warning(
+            "git_ops.pr_api_failed owner=%s repo=%s head=%s status=%s body=%s",
+            owner, repo, head, resp.status_code, resp.text[:300],
+        )
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("git_ops.pr_api_error head=%s error=%s", head, exc)
+    return None
+
+
 async def finish_pr(
     project_path: str, branch: str, base: str, title: str, body: str,
     github_token: str | None,
 ) -> dict:
     """Stage all, commit, push the branch, open a PR. Best-effort.
 
-    Returns {"pushed": bool, "pr_url": str | None}.
+    PR creation prefers the GitHub REST API (works with just the token — no `gh`
+    install required) and falls back to the `gh` CLI. Every failure path is
+    logged so a missing PR is diagnosable instead of silent.
+
+    Returns {"pushed": bool, "pr_url": str | None, "pr_error": str | None}.
     """
     path = str(Path(project_path).expanduser())
     env = _git_env(github_token)
@@ -107,18 +169,46 @@ async def finish_pr(
     # commit — no-op (non-zero) when there's nothing staged; ignore that case.
     await _run(["git", "commit", "-m", title], path, env)
 
-    rc, _, _ = await _run(
+    rc, _, push_err = await _run(
         ["git", "push", "-u", "origin", branch, "--force-with-lease"],
         path, env, timeout=300.0,
     )
     pushed = rc == 0
+    if not pushed:
+        logger.warning("git_ops.push_failed branch=%s error=%s", branch, push_err[:300])
+        return {"pushed": False, "pr_url": None, "pr_error": f"push failed: {push_err[:200]}"}
+
     pr_url: str | None = None
-    if pushed and shutil.which("gh"):
-        rc, out, _ = await _run(
+    pr_error: str | None = None
+
+    # 1. Preferred: REST API (no `gh` dependency).
+    owner_repo = await _remote_owner_repo(path, env)
+    if github_token and owner_repo:
+        owner, repo = owner_repo
+        pr_url = await _create_pr_via_api(owner, repo, base, branch, title, body, github_token)
+
+    # 2. Fallback: gh CLI, if installed.
+    if not pr_url and shutil.which("gh"):
+        rc, out, gh_err = await _run(
             ["gh", "pr", "create", "--base", base, "--head", branch,
              "--title", title, "--body", body],
             path, env, timeout=120.0,
         )
         if rc == 0 and out:
             pr_url = out.strip().splitlines()[-1]
-    return {"pushed": pushed, "pr_url": pr_url}
+        else:
+            pr_error = f"gh pr create failed: {gh_err[:200]}"
+            logger.warning("git_ops.gh_pr_failed branch=%s error=%s", branch, gh_err[:300])
+
+    if not pr_url and pr_error is None:
+        # Pushed, but no PR and no specific error captured above.
+        pr_error = (
+            "no PR created — REST API returned no URL"
+            if (github_token and owner_repo)
+            else "no PR created — missing GitHub token or unrecognized origin remote"
+            if not shutil.which("gh")
+            else "no PR created"
+        )
+        logger.warning("git_ops.no_pr branch=%s reason=%s", branch, pr_error)
+
+    return {"pushed": pushed, "pr_url": pr_url, "pr_error": pr_error}

{devops_bot_sdk-1.4.1 → devops_bot_sdk-1.4.3}/sdk/ipc/handlers.py

@@ -521,15 +521,20 @@ async def handle_pipeline_approve(
                 body=(result.get("result") or "")[:4000],
                 github_token=gh_token,
             )
-            step = f"Pushed {branch_info['branch']}"
+            if pr.get("pushed"):
+                step = f"Pushed {branch_info['branch']}"
+            else:
+                step = f"Push failed for {branch_info['branch']}"
             if pr.get("pr_url"):
                 step += f" · PR: {pr['pr_url']}"
+            elif pr.get("pr_error"):
+                step += f" · PR not created: {pr['pr_error']}"
             await send(Envelope(
                 type="step_update", thread_id=thread_id,
                 data={"status": "running", "current_step": step},
             ).model_dump())
-        except Exception:  # noqa: BLE001
-            pass
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("local_run.finish_pr_failed", error=str(exc))
 
     # ── Notify the user on WhatsApp for a hard error or context overflow ──
     # The backend forwards `message` to WhatsApp (POST /approvals-ml). Best-effort.

{devops_bot_sdk-1.4.1 → devops_bot_sdk-1.4.3}/sdk/local_exec.py

@@ -32,6 +32,14 @@ DEFAULT_ALLOWED_TOOLS = ["Read", "Write", "Edit", "Glob", "Grep", "Bash"]
 # Hard ceiling so a runaway agent can't hang the sidecar forever.
 _DEFAULT_TIMEOUT_S = 1800.0
 
+# StreamReader buffer for the claude CLI's stdout. `--output-format stream-json`
+# emits one JSON object per line, and a single event can embed a whole file's
+# contents (e.g. a Read tool_use_result), easily exceeding asyncio's default
+# 64 KB line limit — which makes readline() raise LimitOverrunError ("Separator
+# is found, but chunk is longer than limit"). 64 MB comfortably covers large
+# file reads/diffs in one event.
+_STREAM_LIMIT_BYTES = 64 * 1024 * 1024
+
 # Markers that indicate the model ran out of context window.
 _CONTEXT_MARKERS = (
     "context window", "context length", "maximum context", "too many tokens",
@@ -135,6 +143,7 @@ async def run_claude_local(
         stdout=asyncio.subprocess.PIPE,
         stderr=asyncio.subprocess.PIPE,
         env=env,
+        limit=_STREAM_LIMIT_BYTES,
     )
 
     result_event: dict | None = None
@@ -145,7 +154,13 @@ async def run_claude_local(
         nonlocal result_event, session_id
         assert proc.stdout is not None
         while True:
-            raw = await proc.stdout.readline()
+            try:
+                raw = await proc.stdout.readline()
+            except ValueError:
+                # Line exceeded even _STREAM_LIMIT_BYTES. readline() has already
+                # advanced past the oversized chunk, so we can safely skip this
+                # one event and keep streaming the rest rather than aborting.
+                continue
             if not raw:
                 break
             line = raw.decode("utf-8", errors="replace").strip()