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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.146
+Version: 1.4.148
 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.148}/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.148
 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.148}/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.148
 
 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.148"   # 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.148}/sdk/ui/ip_allowlist.py

@@ -20,16 +20,52 @@ import ipaddress
 import os
 import socket
 
+_TRUE = ("1", "true", "yes", "on")
+
+
+def _setting(name: str) -> str:
+    """Read an ``AGENTOS_UI_*`` toggle from the process env OR ``~/.agentos/.env``
+    (or a CWD ``.env``), so an operator can set it in the same file as the IP
+    allowlist without editing the service unit. Process env wins."""
+    val = os.environ.get(name, "").strip()
+    if val:
+        return val
+    try:
+        from sdk.config import _dotenv_value
+        return (_dotenv_value(name) or "").strip()
+    except Exception:  # noqa: BLE001 — a config hiccup must never break the server
+        return ""
+
 
 def public_mode() -> bool:
     """Opt-in PUBLIC mode (``AGENTOS_UI_PUBLIC=1``).
 
     When set, the SDK is a public, token-authenticated server: the IP gate is
-    lifted so Swagger (``/docs``) is browsable from any IP and every ``/api/ui/*``
-    path relies SOLELY on the ``co_`` token (``require_token``) as its credential.
-    Off by default — a plain launch stays locked to loopback + allowlisted IPs.
+    lifted so Swagger (``/docs``) is browsable from any IP over http and every
+    ``/api/ui/*`` path relies SOLELY on the ``co_`` token (``require_token``) as its
+    credential. Off by default — a plain launch stays locked to loopback +
+    allowlisted IPs. Read from the process env or ``~/.agentos/.env``.
+    """
+    return _setting("AGENTOS_UI_PUBLIC").lower() in _TRUE
+
+
+def cors_origins() -> list[str] | None:
+    """Browser (CORS) origins to allow, or ``None`` to leave CORS disabled.
+
+    Enabled when the server is PUBLIC (``AGENTOS_UI_PUBLIC=1``) or explicitly via
+    ``AGENTOS_UI_CORS=1``. Origins come from ``AGENTOS_UI_CORS_ORIGINS`` (comma/space
+    separated); default ``["*"]`` (any origin). ``*`` is safe here because every
+    data route is guarded by the ``co_`` token in the ``Authorization`` header (no
+    cookies), so a permissive origin can't be abused via ambient credentials.
+
+    Needed so a browser (e.g. Swagger "Try it out" served from another origin) can
+    call the API — without it the browser blocks the response as a CORS error.
     """
-    return os.environ.get("AGENTOS_UI_PUBLIC", "").strip().lower() in ("1", "true", "yes", "on")
+    enabled = public_mode() or _setting("AGENTOS_UI_CORS").lower() in _TRUE
+    if not enabled:
+        return None
+    raw = _setting("AGENTOS_UI_CORS_ORIGINS").replace(",", " ").split()
+    return raw or ["*"]
 
 
 def _loopback(ip: ipaddress._BaseAddress) -> bool:

{devops_bot_sdk-1.4.146 → devops_bot_sdk-1.4.148}/sdk/ui/server.py

@@ -41,6 +41,22 @@ def create_app():
     # this host's own IPs, and whitelisted IPs (the AI backend) may reach the server
     # AT ALL. Configure via AGENTOS_UI_ALLOWED_IPS or the config.toml `allowed_ips` key.
     app.add_middleware(IPAllowlistMiddleware)
+    # CORS (opt-in — on automatically in PUBLIC mode, or via AGENTOS_UI_CORS=1). Added
+    # AFTER the allowlist so it is the OUTERMOST layer: it answers browser preflight
+    # (OPTIONS) and attaches CORS headers to EVERY response — including a 403 from the
+    # allowlist — so the browser can read the real result instead of a bare "CORS
+    # error". Data routes stay guarded by the co_ token regardless.
+    from sdk.ui.ip_allowlist import cors_origins
+    _cors = cors_origins()
+    if _cors is not None:
+        from fastapi.middleware.cors import CORSMiddleware
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=_cors,
+            allow_methods=["*"],
+            allow_headers=["*"],
+            allow_credentials=False,   # token is in the Authorization header, not cookies
+        )
     app.include_router(api_router)
 
     @app.get("/")

{devops_bot_sdk-1.4.146 → devops_bot_sdk-1.4.148}/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
@@ -30,11 +31,24 @@ WIN_TASK = "AgentOS Control Panel"    # Windows scheduled-task name
 
 
 def _exe() -> str:
-    """Absolute path to the ``agentos-ui`` console script in this venv."""
-    bindir = Path(sys.executable).parent
+    """ABSOLUTE path to the ``agentos-ui`` console script.
+
+    Must be absolute: a service manager (systemd/launchd) does NOT search the
+    user's PATH for ExecStart, so a bare ``agentos-ui`` fails with 203/EXEC when
+    the script lives somewhere like ``~/.local/bin`` (a ``pip --user`` install) —
+    the common case on a VPS. Resolve, in order:
+      1. next to the running interpreter (venv installs),
+      2. on the current PATH (finds ``~/.local/bin`` at install time),
+      3. bare name as a last resort (kept only so install never hard-fails).
+    """
     name = "agentos-ui.exe" if IS_WINDOWS else "agentos-ui"
-    cand = bindir / name
-    return str(cand if cand.exists() else name)
+    cand = Path(sys.executable).parent / name
+    if cand.exists():
+        return str(cand)
+    found = shutil.which(name)
+    if found:
+        return str(Path(found).resolve())
+    return name
 
 
 def _run(argv: list[str]) -> tuple[int, str]:
@@ -285,3 +299,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.148}/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)