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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.146
+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.146 → 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.146
+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.146 → 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.146
+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.146"   # 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.146 → 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
@@ -285,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.146 → 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)