devops-bot-sdk 1.4.13__tar.gz → 1.4.17__tar.gz

{devops_bot_sdk-1.4.13 → devops_bot_sdk-1.4.17}/PKG-INFO

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

{devops_bot_sdk-1.4.13 → devops_bot_sdk-1.4.17}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.13 → devops_bot_sdk-1.4.17}/pyproject.toml

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

{devops_bot_sdk-1.4.13 → devops_bot_sdk-1.4.17}/sdk/__init__.py

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

{devops_bot_sdk-1.4.13 → devops_bot_sdk-1.4.17}/sdk/client.py

@@ -36,7 +36,7 @@ from sdk.sse import _check_status, stream_with_reconnect
 
 logger = logging.getLogger(__name__)
 
-SDK_VERSION    = "1.4.13"
+SDK_VERSION    = "1.4.17"
 _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.13 → devops_bot_sdk-1.4.17}/sdk/ipc/handlers.py

@@ -149,6 +149,7 @@ def _build_local_prompt(
     structured_plan: dict | None,
     human_instructions: str | None = None,
     agent_mode: bool = True,
+    git_managed: bool = True,
 ) -> str:
     """Compose the coding prompt for the local claude CLI from the server plan.
 
@@ -204,14 +205,29 @@ def _build_local_prompt(
             "above are authoritative if anything conflicts) ===\n"
             + _clip_text(user_input.strip())
         )
-    parts.append(
-        "Implement all of the above in the current project directory. "
-        "Create and edit every file needed for a complete, working result.\n"
-        "Git for THIS repo is handled for you: a feature branch is already checked "
-        "out, and the system will commit, push, and open the PR after you finish — "
-        "so do NOT create branches, commit, push, or open a PR for the current repo. "
-        "(You may still clone and open PRs for OTHER repositories the instructions name.)"
-    )
+    if git_managed:
+        # The target is a git repo the SDK manages — it branches before and
+        # commits/pushes/opens the PR after, so the agent must not touch git here.
+        parts.append(
+            "Complete all of the above in the current project directory. "
+            "Create and edit every file needed for a complete, working result.\n"
+            "Git for THIS repo is handled for you: a feature branch is already checked "
+            "out, and the system will commit, push, and open the PR after you finish — "
+            "so do NOT create branches, commit, push, or open a PR for the current repo. "
+            "(You may still clone and open PRs for OTHER repositories the instructions name.)"
+        )
+    else:
+        # Plain local working folder (no GitHub repo / not under our git control) —
+        # e.g. a non-developer (BA/analyst) task that just produces files/docs.
+        parts.append(
+            "Complete all of the above in the current working directory by creating and "
+            "editing the necessary files (documents, .md files, spreadsheets, code — "
+            "whatever the task asks for). This is a plain local folder, NOT a git "
+            "repository under our control: do NOT initialise git, create branches, "
+            "commit, push, or open a PR for it unless the instructions explicitly say so. "
+            "Just produce the requested deliverables here. (You may still clone and open "
+            "PRs for OTHER repositories the instructions explicitly name.)"
+        )
     # agentMode=true → require approval before crucial/irreversible actions.
     if agent_mode:
         from sdk import crucial
@@ -399,7 +415,6 @@ async def _code_one_repo(
     repo_path: str,
     repo_url: str | None,
     pending: dict,
-    prompt: str,
     gh_token: str | None,
     agent_mode: bool,
     approval_dir: str | None,
@@ -474,6 +489,14 @@ async def _code_one_repo(
         data={"status": "running", "current_step": f"Executing locally in {name} (claude_code)"},
     ).model_dump())
 
+    # Build the prompt with framing that matches the target: a git repo we manage
+    # (branch + PR) vs a plain local folder (BA/analyst deliverables, no git/PR).
+    prompt = _build_local_prompt(
+        pending["user_input"], pending.get("structured_plan"),
+        pending.get("human_instructions"),
+        agent_mode=agent_mode, git_managed=bool(branch_info),
+    )
+
     # 3. initial claude run
     result = await local_exec.run_claude_local(
         prompt, repo_path, on_event=_on_event,
@@ -636,11 +659,8 @@ async def handle_pipeline_approve(
         return
 
     # ── Approved: run the local claude CLI on EACH repo the ticket names ──
-    prompt = _build_local_prompt(
-        pending["user_input"], pending.get("structured_plan"),
-        pending.get("human_instructions"),
-        agent_mode=bool(pending.get("agent_mode", True)),
-    )
+    # 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))
 
     # Fetch the user's GitHub token from the backend so the local agent can
@@ -675,7 +695,7 @@ async def handle_pipeline_approve(
             runs.append(await _code_one_repo(
                 client, repo_path=tgt["path"], repo_url=tgt.get("url"),
                 base=tgt.get("base"),
-                pending=pending, prompt=prompt, gh_token=gh_token,
+                pending=pending, gh_token=gh_token,
                 agent_mode=agent_mode, approval_dir=approval_dir,
                 send=send, thread_id=thread_id, task_id=task_id,
             ))
@@ -1202,8 +1222,13 @@ _PATH_ROOTS = (
     "home|root|var|opt|srv|usr|mnt|media|data|app|apps|"
     "project|projects|workspace|workspaces|repos|code|tmp|Users"
 )
-_ABS_PATH_RE = re.compile(rf"(?<![\w.])/(?:{_PATH_ROOTS})(?:/[A-Za-z0-9._\-]+)+")
-_HOME_PATH_RE = re.compile(r"(?<![\w.])~(?:/[A-Za-z0-9._\-]+)+")
+# Unix / ~-home paths. Folder names may contain SPACES too (e.g.
+# "/home/me/BA activities/repo"), so segments allow spaces and the path runs to
+# end-of-line. The root is anchored to a known top-level dir to limit false
+# positives in prose; for an inline path followed by other words on the SAME
+# line, quote it (see _QUOTED_PATH_RE) to avoid grabbing the trailing text.
+_ABS_PATH_RE = re.compile(rf"(?<![\w.])/(?:{_PATH_ROOTS})(?:/[A-Za-z0-9._\- ]+)+")
+_HOME_PATH_RE = re.compile(r"(?<![\w.])~(?:/[A-Za-z0-9._\- ]+)+")
 # Windows path. Folder names may contain SPACES (e.g. "BA activities clone"), so a
 # segment is any run of valid path chars (everything except \ / : * ? " < > | and
 # newline) up to the next separator — it must NOT stop at the first space.
@@ -1429,6 +1454,19 @@ def _extract_repo_targets(text: str | None) -> list[dict]:
     return targets
 
 
+def _task_created_key(task: dict):
+    """Sortable Jira creation time for a raw task (e.g. ``createdAt`` =
+    "2026-06-22T15:07:52.452Z"). Used to process tickets oldest-first. A
+    missing/invalid timestamp sorts LAST so well-formed, earlier tickets win."""
+    from datetime import datetime, timezone
+
+    raw = str(task.get("createdAt") or task.get("created_at") or "").strip()
+    try:
+        return datetime.fromisoformat(raw.replace("Z", "+00:00"))
+    except (ValueError, TypeError):
+        return datetime.max.replace(tzinfo=timezone.utc)
+
+
 def _resolve_local_project_path(task: dict, payload: dict) -> str:
     """Pick the LOCAL directory to write a task's code into (on the user's box).
 
@@ -1579,6 +1617,9 @@ async def handle_orchestrate_auto_local_run(
 
         # RAW /tasks-ml records carry agentMode / jiraIssueKey / humanInstructions.
         tasks = await client.list_todo_tasks_raw(status="To Do")
+        # Process oldest-created first (FIFO by Jira `createdAt`) so the ticket
+        # raised earliest is started first. Unknown/invalid timestamps sort last.
+        tasks = sorted(tasks, key=_task_created_key)
 
         await send(Envelope(
             type="pipeline_started", thread_id=thread_id,

{devops_bot_sdk-1.4.13 → devops_bot_sdk-1.4.17}/sdk/local_exec.py

@@ -22,6 +22,7 @@ import json
 import os
 import re
 import shutil
+from datetime import datetime
 from pathlib import Path
 from typing import Any, Awaitable, Callable
 
@@ -92,6 +93,70 @@ def _parse_reset_epoch(text: str | None) -> int | None:
     return None
 
 
+# ── Per-run claude log file (on the user's machine, local-timezone stamps) ──
+# Every local claude run writes a readable, timestamped transcript so a box can
+# be debugged after the fact. Dir is AGENTOS_LOG_DIR or ~/.agentos/logs.
+
+def _open_run_log(project_path: str, resume_session_id: str | None):
+    """Open a per-run log file under the local logs dir. Returns (file, path) or
+    (None, None). Best-effort — never breaks the run."""
+    try:
+        base = os.getenv("AGENTOS_LOG_DIR") or str(Path.home() / ".agentos" / "logs")
+        d = Path(base).expanduser()
+        d.mkdir(parents=True, exist_ok=True)
+        now = datetime.now().astimezone()                     # local system tz
+        proj = Path(project_path).name or "run"
+        # Filenames are filesystem-safe (no ':'); stamp encodes the local tz offset.
+        fname = f"claude_{proj}_{now.strftime('%Y-%m-%d_%H-%M-%S%z')}.log"
+        path = d / fname
+        f = open(path, "a", encoding="utf-8")
+        return f, str(path)
+    except Exception:  # noqa: BLE001
+        return None, None
+
+
+def _logln(f, msg: str) -> None:
+    """Append a local-timezone timestamped line. Best-effort."""
+    if not f:
+        return
+    try:
+        ts = datetime.now().astimezone().strftime("%Y-%m-%d %H:%M:%S %Z")
+        f.write(f"[{ts}] {msg}\n")
+        f.flush()
+    except Exception:  # noqa: BLE001
+        pass
+
+
+def _event_logline(event: dict) -> str | None:
+    """A compact, human-readable line for one stream-json event (or None to skip)."""
+    def _short(s, n=200):
+        return " ".join(str(s or "").split())[:n]
+
+    t = event.get("type")
+    if t == "system":
+        return f"SYSTEM {event.get('subtype', '')}".rstrip()
+    if t == "assistant":
+        parts: list[str] = []
+        for c in event.get("message", {}).get("content", []):
+            if c.get("type") == "text" and c.get("text", "").strip():
+                parts.append("TEXT: " + _short(c["text"], 300))
+            elif c.get("type") == "tool_use":
+                inp = c.get("input") or {}
+                detail = (inp.get("command") or inp.get("file_path") or inp.get("pattern")
+                          or inp.get("url") or inp.get("description") or "")
+                parts.append(f"TOOL {c.get('name', 'tool')}" + (f" → {_short(detail)}" if detail else ""))
+        return " | ".join(parts) if parts else None
+    if t == "user":
+        tr = event.get("tool_use_result") or event.get("message", {})
+        if isinstance(tr, dict) and tr.get("is_error"):
+            return "TOOL_ERROR: " + _short(tr.get("content") or tr.get("stderr") or "", 300)
+        return None
+    if t == "result":
+        return (f"RESULT subtype={event.get('subtype')} is_error={event.get('is_error')} "
+                f"cost=${event.get('total_cost_usd', 0)}")
+    return None
+
+
 def _ctx_exceeded(text: str | None) -> bool:
     low = (text or "").lower()
     return any(m in low for m in _CONTEXT_MARKERS)
@@ -157,8 +222,12 @@ async def run_claude_local(
     path.mkdir(parents=True, exist_ok=True)
 
     tools = allowed_tools or DEFAULT_ALLOWED_TOOLS
+    # The prompt is fed via STDIN (not as an argv), so a long plan/instructions
+    # can't blow past the OS command-line limit — on Windows that's ~32 KB and
+    # raised "The command line is too long." `claude -p` reads the prompt from a
+    # piped stdin.
     cmd = [
-        cli, "-p", prompt,
+        cli, "-p",
         "--output-format", "stream-json",
         "--verbose",                       # required for stream-json
         "--permission-mode", "acceptEdits",  # apply file edits without prompting
@@ -205,12 +274,24 @@ async def run_claude_local(
     proc = await asyncio.create_subprocess_exec(
         *cmd,
         cwd=str(path),
+        stdin=asyncio.subprocess.PIPE,
         stdout=asyncio.subprocess.PIPE,
         stderr=asyncio.subprocess.PIPE,
         env=env,
         limit=_STREAM_LIMIT_BYTES,
     )
 
+    # Feed the prompt via stdin (claude -p reads it), then close stdin so claude
+    # starts. Bounded write before draining stdout — no deadlock (claude buffers
+    # the prompt before emitting any events).
+    if proc.stdin is not None:
+        try:
+            proc.stdin.write((prompt or "").encode("utf-8"))
+            await proc.stdin.drain()
+            proc.stdin.close()
+        except Exception:  # noqa: BLE001 — broken pipe if claude already exited
+            pass
+
     result_event: dict | None = None
     files_changed: list[str] = []
     session_id: str | None = resume_session_id
@@ -218,6 +299,26 @@ async def run_claude_local(
     started = _time.monotonic()
     stall = {"timed_out": False, "reason": ""}
 
+    # Per-run local log (timezone-stamped) for after-the-fact debugging.
+    logf, logpath = _open_run_log(str(path), resume_session_id)
+    _logln(logf, f"START claude run | project={path} | resume={resume_session_id or '-'} "
+                 f"| idle_timeout={idle_timeout:.0f}s | cap={timeout:.0f}s")
+    _logln(logf, "PROMPT: " + " ".join((prompt or "").split())[:600])
+
+    def _finish(result: dict) -> dict:
+        """Write the run footer, close the log, and return the result."""
+        _logln(logf, f"END ok={result.get('ok')} error={result.get('error')} "
+                     f"tokens={result.get('total_tokens')} cost=${result.get('cost_usd')} "
+                     f"files_changed={len(result.get('files_changed') or [])} "
+                     f"limit_exceeded={result.get('limit_exceeded')} "
+                     f"session={result.get('session_id')}")
+        if logf:
+            try:
+                logf.close()
+            except Exception:  # noqa: BLE001
+                pass
+        return result
+
     async def _drain_stdout() -> None:
         nonlocal result_event, session_id
         assert proc.stdout is not None
@@ -250,6 +351,10 @@ async def run_claude_local(
             except json.JSONDecodeError:
                 continue
 
+            _ll = _event_logline(event)
+            if _ll:
+                _logln(logf, _ll)
+
             # Capture the claude session id (emitted on init + result events) so
             # the caller can --resume this exact session later.
             if event.get("session_id"):
@@ -284,23 +389,25 @@ async def run_claude_local(
             proc.kill()
         except ProcessLookupError:
             pass
-        return {
+        return _finish({
             "ok": False, "result": "", "error": f"claude CLI timed out — {stall['reason']}",
             "input_tokens": 0, "output_tokens": 0, "total_tokens": 0,
             "cost_usd": 0.0, "files_changed": files_changed,
             "session_id": session_id, "context_exceeded": False,
-        }
+        })
 
     if result_event is None:
         stderr = (await proc.stderr.read()).decode("utf-8", errors="replace") if proc.stderr else ""
         err = stderr.strip()[:500] or "no result event from claude CLI"
-        return {
+        if stderr.strip():
+            _logln(logf, "STDERR: " + " ".join(stderr.split())[:600])
+        return _finish({
             "ok": False, "result": "", "error": err,
             "input_tokens": 0, "output_tokens": 0, "total_tokens": 0,
             "cost_usd": 0.0, "files_changed": files_changed,
             "session_id": session_id, "context_exceeded": _ctx_exceeded(err),
             "limit_exceeded": _is_limit(err), "limit_reset_epoch": _parse_reset_epoch(err),
-        }
+        })
 
     usage = result_event.get("usage") or {}
     in_tok = int(usage.get("input_tokens", 0) or 0)
@@ -321,7 +428,7 @@ async def run_claude_local(
     elif limit_hit:
         err_text = result_text or "claude usage limit reached"
 
-    return {
+    return _finish({
         "ok": (not is_error) and (not limit_hit),
         "result": result_text,
         "input_tokens": in_tok,
@@ -334,4 +441,4 @@ async def run_claude_local(
         "context_exceeded": is_error and _ctx_exceeded(err_text),
         "limit_exceeded": limit_hit,
         "limit_reset_epoch": reset_epoch,
-    }
+    })