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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.13
+Version: 1.4.14
 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.14}/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.14
 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.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devops-bot-sdk"
-version = "1.4.13"
+version = "1.4.14"
 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.14}/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.14
 
 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.14"
 __author__  = "AgentOS"
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.4.13 → devops_bot_sdk-1.4.14}/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.14"
 _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.14}/sdk/ipc/handlers.py

@@ -1202,8 +1202,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 +1434,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 +1597,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.14}/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)
@@ -218,6 +283,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 +335,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 +373,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 +412,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 +425,4 @@ async def run_claude_local(
         "context_exceeded": is_error and _ctx_exceeded(err_text),
         "limit_exceeded": limit_hit,
         "limit_reset_epoch": reset_epoch,
-    }
+    })