devops-bot-sdk 1.4.145__tar.gz → 1.4.147__tar.gz

{devops_bot_sdk-1.4.145 → devops_bot_sdk-1.4.147}/PKG-INFO

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

{devops_bot_sdk-1.4.145 → devops_bot_sdk-1.4.147}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.145 → devops_bot_sdk-1.4.147}/sdk/__init__.py

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

@@ -11,7 +11,6 @@ from __future__ import annotations
 
 import json
 import logging
-import shutil
 import subprocess
 from pathlib import Path
 
@@ -70,7 +69,8 @@ def _connectors() -> list[dict]:
 
 def _mcp_servers() -> list[dict]:
     """Installed MCP servers / Claude plugins, parsed from ``claude mcp list``."""
-    cli = shutil.which("claude")
+    from sdk.local_exec import claude_cli_path
+    cli = claude_cli_path()
     if not cli:
         return []
     try:

{devops_bot_sdk-1.4.145 → devops_bot_sdk-1.4.147}/sdk/local_exec.py

@@ -22,6 +22,7 @@ import json
 import os
 import re
 import shutil
+import subprocess
 import sys
 from datetime import datetime, timedelta
 from pathlib import Path
@@ -240,7 +241,21 @@ EventHandler = Callable[[dict], Awaitable[None]]
 
 
 def claude_cli_path() -> str | None:
-    """Absolute path to the `claude` CLI if installed on PATH, else None."""
+    """Absolute path to the `claude` CLI, or None if it isn't on PATH.
+
+    Resolution order:
+      1. ``AGENTOS_CLAUDE_CLI`` env var — explicit path override (escape hatch for
+         an install in a non-standard location).
+      2. ``PATH`` (``shutil.which``) — cross-platform, no guessing.
+
+    The service must therefore RUN with a PATH that includes the CLI. The install
+    step bakes that in (see ``sdk.ui.service`` — systemd ``Environment=PATH`` /
+    launchd ``EnvironmentVariables``; Windows tasks inherit the user's PATH), so
+    ``engine=claude_code`` works without anyone editing a unit file.
+    """
+    override = os.environ.get("AGENTOS_CLAUDE_CLI", "").strip()
+    if override and Path(override).exists():
+        return override
     return shutil.which("claude")
 
 
@@ -249,6 +264,54 @@ def is_available() -> bool:
     return claude_cli_path() is not None
 
 
+def claude_status(timeout: float = 15.0) -> dict:
+    """Readiness of the local Claude Code CLI: installed AND logged in.
+
+    Runs ``claude auth status`` (which prints structured JSON) so the panel /
+    health surface can show a non-technical operator one clear signal — "connected
+    as you@org" vs "not logged in" — instead of a raw CLI error surfacing only when
+    a job runs. All failures degrade to ``logged_in: False`` with an ``error`` note;
+    this never raises.
+
+    Returns::
+
+        {"installed": bool, "logged_in": bool, "path": str|None,
+         "auth_method": str|None, "email": str|None, "org": str|None,
+         "error": str|None}
+    """
+    cli = claude_cli_path()
+    if not cli:
+        return {"installed": False, "logged_in": False, "path": None,
+                "auth_method": None, "email": None, "org": None,
+                "error": "Claude Code CLI not found. Install it or set AGENTOS_CLAUDE_CLI."}
+    try:
+        proc = subprocess.run([cli, "auth", "status"], capture_output=True,
+                              text=True, timeout=timeout)
+    except Exception as exc:  # noqa: BLE001 — timeout / OSError; never raise to caller
+        return {"installed": True, "logged_in": False, "path": cli, "auth_method": None,
+                "email": None, "org": None, "error": f"`claude auth status` failed: {exc}"}
+
+    out = (proc.stdout or "").strip()
+    try:
+        data = json.loads(out)
+    except Exception:  # noqa: BLE001 — older CLIs may print human text, not JSON
+        logged = "logged in" in out.lower()
+        return {"installed": True, "logged_in": logged, "path": cli, "auth_method": None,
+                "email": None, "org": None,
+                "error": None if logged else ((proc.stderr or out or "not logged in").strip()[:200])}
+
+    logged = bool(data.get("loggedIn"))
+    return {
+        "installed": True,
+        "logged_in": logged,
+        "path": cli,
+        "auth_method": data.get("authMethod"),
+        "email": data.get("email"),
+        "org": data.get("orgName") or data.get("orgId"),
+        "error": None if logged else "Not logged in — run `claude` on the VPS to sign in.",
+    }
+
+
 # Cache the discovered MCP allow-entries for the process lifetime — the set of
 # configured servers doesn't change mid-run, and `claude mcp list` does a network
 # health check (~seconds) we don't want to repeat per ticket.
@@ -396,7 +459,9 @@ async def run_claude_local(
     cli = claude_cli_path()
     if not cli:
         return {
-            "ok": False, "result": "", "error": "claude CLI not found on PATH",
+            "ok": False, "result": "",
+            "error": ("Claude Code CLI not found. Install it, or if it is installed "
+                      "in a non-standard location set AGENTOS_CLAUDE_CLI to its full path."),
             "input_tokens": 0, "output_tokens": 0, "total_tokens": 0,
             "cost_usd": 0.0, "files_changed": [],
         }
@@ -461,6 +526,15 @@ async def run_claude_local(
     # the user's global git config. Tokens stay in the subprocess env only.
     env = dict(os.environ)
 
+    # Make sure the CLI's own directory is on the subprocess PATH: node/gh and the
+    # CLI's sibling tools usually live alongside it, and under a minimal service
+    # PATH they'd otherwise be missing. Prepend the resolved binary's dir only —
+    # no guessing beyond that — so anything the operator exported still wins.
+    _cli_dir = str(Path(cli).resolve().parent)
+    _cur_path = env.get("PATH", "")
+    if _cli_dir not in _cur_path.split(os.pathsep):
+        env["PATH"] = _cli_dir + (os.pathsep + _cur_path if _cur_path else "")
+
     # A custom agent's persisted API keys (sdk.agents.secrets) are overlaid here
     # so they reach the subprocess (and any MCP servers it spawns) WITHOUT ever
     # touching the ambient os.environ of this process — same "subprocess env only"

{devops_bot_sdk-1.4.145 → devops_bot_sdk-1.4.147}/sdk/ui/service.py

@@ -17,6 +17,7 @@ Everything is best-effort and returns ``(ok, message)`` so the caller (the
 from __future__ import annotations
 
 import os
+import re
 import shutil
 import subprocess
 import sys
@@ -51,6 +52,30 @@ def _systemd_available() -> bool:
     return bool(shutil.which("systemctl")) and Path("/run/systemd/system").exists()
 
 
+def _service_path_env() -> str:
+    """PATH for the service environment.
+
+    A service (systemd/launchd) runs with a minimal PATH that omits ~/.local/bin,
+    nvm/Homebrew, etc. — exactly where the ``claude`` CLI and its node/git/gh
+    runtime live. Prepend the resolved CLI's own directory and ~/.local/bin to the
+    standard system dirs so ``engine=claude_code`` works with no manual PATH edits.
+    """
+    base = ["/usr/local/sbin", "/usr/local/bin", "/usr/sbin", "/usr/bin", "/sbin", "/bin"]
+    extra = [str(Path.home() / ".local" / "bin")]
+    try:
+        from sdk.local_exec import claude_cli_path
+        cli = claude_cli_path()
+        if cli:
+            extra.append(str(Path(cli).resolve().parent))
+    except Exception:  # noqa: BLE001 — discovery must never break install
+        pass
+    ordered: list[str] = []
+    for d in extra + base:
+        if d and d not in ordered:
+            ordered.append(d)
+    return ":".join(ordered)
+
+
 def _unit_text(host: str, port: int, home: str) -> str:
     exec_line = f"{_exe()} --host {host} --port {port} --no-browser"
     return (
@@ -64,6 +89,7 @@ def _unit_text(host: str, port: int, home: str) -> str:
         "Restart=always\n"
         "RestartSec=5\n"
         f"Environment=HOME={home}\n"
+        f"Environment=PATH={_service_path_env()}\n"
         f"WorkingDirectory={home}\n\n"
         "[Install]\n"
         f"WantedBy={{target}}\n"
@@ -145,6 +171,9 @@ def _install_launchd(host: str, port: int) -> tuple[bool, str]:
         f'    <string>{exe}</string><string>--host</string><string>{host}</string>\n'
         f'    <string>--port</string><string>{port}</string><string>--no-browser</string>\n'
         '  </array>\n'
+        '  <key>EnvironmentVariables</key><dict>\n'
+        f'    <key>PATH</key><string>{_service_path_env()}</string>\n'
+        '  </dict>\n'
         '  <key>RunAtLoad</key><true/>\n'
         '  <key>KeepAlive</key><true/>\n'
         '</dict></plist>\n'
@@ -257,3 +286,174 @@ def restart() -> tuple[bool, str]:
         return (rc == 0), (f"restarted systemd service '{SERVICE_NAME}'." if rc == 0
                            else out or f"systemctl restart {SERVICE_NAME} failed")
     return False, "no supported service manager found — restart the panel manually (`agentos-ui`)."
+
+
+def _systemd_unit_candidates() -> list[Path]:
+    """Both places a systemd unit can live, system scope first."""
+    return [
+        Path("/etc/systemd/system") / f"{SERVICE_NAME}.service",
+        Path.home() / ".config" / "systemd" / "user" / f"{SERVICE_NAME}.service",
+    ]
+
+
+def _existing_systemd_unit() -> Path | None:
+    """The installed unit file, checking BOTH system and user scope regardless of
+    the current privilege — so a non-root ``agentos-auto update`` still finds a
+    system service installed via ``sudo agentos-ui install`` (and vice-versa)."""
+    for p in _systemd_unit_candidates():
+        try:
+            if p.exists():
+                return p
+        except OSError:
+            continue
+    return None
+
+
+def _service_definition_path() -> Path:
+    """On-disk service definition — an EXISTING unit if there is one (either scope),
+    else the path we would CREATE at the current privilege."""
+    if IS_WINDOWS:                          # schtasks has no file; handled separately
+        return Path()
+    if IS_MAC:
+        return _mac_plist_path()
+    existing = _existing_systemd_unit()
+    if existing:
+        return existing
+    is_root = hasattr(os, "geteuid") and os.geteuid() == 0
+    base = Path("/etc/systemd/system") if is_root else Path.home() / ".config" / "systemd" / "user"
+    return base / f"{SERVICE_NAME}.service"
+
+
+def _needs_root_for_existing() -> bool:
+    """True when a SYSTEM unit is installed but we're not root — so we must not
+    silently create a conflicting *user* unit; the caller should ask for sudo."""
+    if IS_WINDOWS or IS_MAC:
+        return False
+    is_root = hasattr(os, "geteuid") and os.geteuid() == 0
+    existing = _existing_systemd_unit()
+    return (existing is not None
+            and existing.parent == Path("/etc/systemd/system")
+            and not is_root)
+
+
+def is_installed() -> bool:
+    """True when a managed agentos-ui service/unit exists (any platform, any scope).
+
+    Best-effort and never raises — used by the updater to decide whether an upgrade
+    should create, regenerate, or restart the service.
+    """
+    try:
+        if IS_WINDOWS:
+            rc, _ = _run(["schtasks", "/Query", "/TN", WIN_TASK])
+            return rc == 0
+        if IS_MAC:
+            return _mac_plist_path().exists()
+        return _existing_systemd_unit() is not None
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def _is_active() -> bool:
+    """True when the managed service is currently running (read-only query)."""
+    try:
+        if IS_WINDOWS:
+            _, out = _run(["schtasks", "/Query", "/TN", WIN_TASK, "/FO", "LIST", "/V"])
+            return "Running" in out
+        if IS_MAC:
+            rc, out = _run(["launchctl", "list", _MAC_LABEL])
+            return rc == 0 and bool(out.strip())
+        existing = _existing_systemd_unit()
+        user = existing is not None and existing.parent.name == "user"
+        sysctl = ["systemctl", "--user"] if user else ["systemctl"]
+        _, out = _run([*sysctl, "is-active", SERVICE_NAME])
+        return out.strip() == "active"
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def _installed_host_port() -> tuple[str, int]:
+    """Read the host/port the service was installed with, so a refresh preserves
+    them instead of resetting to the install() defaults. Falls back to 0.0.0.0:8765.
+    """
+    host, port = "0.0.0.0", 8765
+    text = ""
+    try:
+        if IS_WINDOWS:
+            _, text = _run(["schtasks", "/Query", "/TN", WIN_TASK, "/V", "/FO", "LIST"])
+        else:
+            p = _service_definition_path()
+            text = p.read_text() if p and p.exists() else ""
+    except Exception:  # noqa: BLE001
+        text = ""
+    clean = re.sub(r"<[^>]+>", " ", text)   # flatten plist <string> tags to spaces
+    m = re.search(r"--host\s+(\S+)", clean)
+    if m:
+        host = m.group(1).strip().strip('"')
+    m = re.search(r"--port\s+(\d+)", clean)
+    if m:
+        port = int(m.group(1))
+    return host, port
+
+
+def refresh() -> tuple[bool, str]:
+    """Regenerate the service definition and restart it after an SDK upgrade.
+
+    ``agentos-auto update`` only pip-upgrades the package; the on-disk unit and the
+    running process are untouched. So a change to the generated unit (e.g. the
+    baked-in PATH that lets the service find the ``claude`` CLI) or to the code
+    never takes effect until this runs. Regenerating rewrites the unit with the
+    upgraded SDK's definition (preserving the installed host/port), and the restart
+    both applies the new unit and loads the new code.
+
+    No-op returning ``(False, msg)`` when no managed service is installed, so a
+    manually-launched panel is left alone.
+    """
+    if not is_installed():
+        return False, "no managed service installed — nothing to refresh."
+    if _needs_root_for_existing():
+        return False, ("the panel runs as a system service — re-run with sudo "
+                       "(`sudo agentos-ui install`) to apply the update.")
+    host, port = _installed_host_port()
+    ok, msg = install(host, port)           # rewrites unit/plist/task + daemon-reload
+    if not ok:
+        return False, f"could not regenerate service: {msg}"
+    # `enable --now` / launchctl load won't restart an ALREADY-running unit, so
+    # force a restart to apply the regenerated definition and load the new code.
+    rok, rmsg = restart()
+    return (True, f"service refreshed ({host}:{port}); {rmsg}" if rok
+            else f"service definition regenerated ({host}:{port}) but restart needs attention: {rmsg}")
+
+
+def _service_disabled() -> bool:
+    return os.environ.get("AGENTOS_NO_SERVICE", "").strip().lower() in ("1", "true", "yes", "on")
+
+
+def ensure(restart_running: bool = False) -> tuple[bool, str]:
+    """Make sure the panel service EXISTS and is running the current SDK.
+
+    This is what lets ``agentos-auto update`` yield a working 24/7 service without a
+    separate ``agentos-ui install`` step:
+
+      * not installed                     → create it (``install``)
+      * installed + code changed          → ``refresh`` (regenerate unit + restart)
+        (pass ``restart_running=True`` after a real upgrade)
+      * installed + unchanged + running   → leave it alone
+      * installed + unchanged + stopped   → start it
+
+    Best-effort; opt out entirely with ``AGENTOS_NO_SERVICE=1`` (e.g. a box that
+    runs the panel manually or only uses the SDK as a library).
+    """
+    if _service_disabled():
+        return False, "AGENTOS_NO_SERVICE set — leaving the service unmanaged."
+    if not is_installed():
+        ok, msg = install()                 # create at the current privilege
+        return ok, (f"service created — {msg}" if ok else f"could not create service: {msg}")
+    if _needs_root_for_existing():
+        return False, ("a system service is installed — run `sudo agentos-ui install` "
+                       "to apply updates and manage it.")
+    if restart_running:
+        return refresh()
+    if _is_active():
+        return True, "service already running."
+    rok, rmsg = restart()                   # installed but down → bring it back up
+    return rok, (f"service was down — started; {rmsg}" if rok else rmsg)

{devops_bot_sdk-1.4.145 → devops_bot_sdk-1.4.147}/sdk/ui/setup_manager.py

@@ -64,6 +64,19 @@ def sdk_version() -> str:
         return "unknown"
 
 
+def claude_readiness() -> dict:
+    """Claude Code CLI readiness (installed + logged in) for the /status surface.
+
+    Guarded: any failure degrades to a not-ready dict rather than breaking /status.
+    """
+    try:
+        from sdk.local_exec import claude_status
+        return claude_status()
+    except Exception as exc:  # noqa: BLE001
+        return {"installed": False, "logged_in": False, "path": None,
+                "auth_method": None, "email": None, "org": None, "error": str(exc)}
+
+
 def environment_info() -> dict:
     """Env snapshot for the /status endpoint and setup wizard."""
     vp = running_venv()
@@ -78,6 +91,7 @@ def environment_info() -> dict:
         "expected_agentsystem_root": str(root),
         "agentsystem_exists": root.exists(),
         "sdk_version": sdk_version(),
+        "claude": claude_readiness(),
     }
 
 

{devops_bot_sdk-1.4.145 → devops_bot_sdk-1.4.147}/sdk/updater.py

@@ -273,6 +273,37 @@ def self_update() -> bool:
     return False
 
 
+def _ensure_service(quiet: bool = False, *, restart: bool = False) -> None:
+    """Ensure the panel service exists and runs the current SDK, after an update check.
+
+    Without this, ``agentos-auto update`` pip-upgrades the code but leaves the old
+    systemd unit / launchd plist and the old running process in place — so unit
+    changes (e.g. the baked-in PATH that lets the service find ``claude``) and new
+    code silently never take effect, and a box that never ran ``agentos-ui install``
+    has no service at all. ``service.ensure`` creates it when missing, refreshes it
+    after a real upgrade (``restart=True``), and starts it if it's down — so a plain
+    ``agentos-auto update`` reliably leaves ``systemctl status agentos-ui`` running.
+
+    Best-effort and never raises. Silent on a box without the ``[ui]`` extra (no
+    panel to manage) and opt-out via ``AGENTOS_NO_SERVICE=1``.
+
+    Safe here because ``auto_update`` runs from the short-lived ``agentos-auto``
+    process, not inside the long-running panel — restarting the panel can't kill
+    the updater mid-run.
+    """
+    try:
+        from sdk.ui import service
+    except Exception:  # noqa: BLE001 — no [ui] extra installed → no panel service
+        return
+    try:
+        ok, msg = service.ensure(restart_running=restart)
+        if not quiet and msg:
+            print(f"↻ {msg}" if ok else f"(service: {msg})")
+    except Exception as exc:  # noqa: BLE001 — an update must never fail on the service step
+        if not quiet:
+            print(f"(service check failed: {exc})")
+
+
 def auto_update(quiet: bool = False) -> tuple[bool, str, str | None]:
     """Check for a newer version and upgrade if one exists.
 
@@ -292,13 +323,16 @@ def auto_update(quiet: bool = False) -> tuple[bool, str, str | None]:
     if not is_github:
         latest = latest_pypi_version()
         if not latest or _vtuple(latest) <= _vtuple(cur):
+            _ensure_service(quiet, restart=False)   # already current — just self-heal the service
             return (False, cur, latest)
         if not quiet:
             print(f"updating {_DIST} {cur} → {latest} …")
         ok = self_update()
         if not quiet and ok:
             print("✓ updated.")
-        # silent on failure — continue on the existing version without noise
+        # Ensure the service exists + runs the new code (restart only on a real
+        # upgrade); also self-heals a missing/down service when already current.
+        _ensure_service(quiet, restart=ok)
         return (ok, cur, latest if ok else None)
 
     # GitHub path
@@ -313,6 +347,7 @@ def auto_update(quiet: bool = False) -> tuple[bool, str, str | None]:
         elif ok:
             print(f"✓ already up to date (v{cur}).")
         # silent on failure — continue on the existing version without noise
+    _ensure_service(quiet, restart=updated)
     return (updated, cur, after if updated else None)