devops-bot-sdk 1.6.49__tar.gz → 1.6.52__tar.gz

{devops_bot_sdk-1.6.49 → devops_bot_sdk-1.6.52}/PKG-INFO

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

{devops_bot_sdk-1.6.49 → devops_bot_sdk-1.6.52}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.49 → devops_bot_sdk-1.6.52}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -201,6 +201,7 @@ tests/test_schedule_outputs_and_plans.py
 tests/test_scheduler.py
 tests/test_self_report.py
 tests/test_service_token_warning.py
+tests/test_stale_panel_restart.py
 tests/test_swagger_command.py
 tests/test_task_file_and_plan_run.py
 tests/test_task_file_format_doc.py
@@ -212,6 +213,7 @@ tests/test_ui_gate.py
 tests/test_ui_lifespan.py
 tests/test_update_timer.py
 tests/test_updater_extras.py
+tests/test_updater_pep668.py
 tests/test_updater_reports_the_truth.py
 tests/test_url_access.py
 tests/test_vps_health.py

{devops_bot_sdk-1.6.49 → devops_bot_sdk-1.6.52}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.6.49
+Version: 1.6.52
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -34,7 +34,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.6.49"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.52"   # 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.6.49 → devops_bot_sdk-1.6.52}/sdk/activity/collectors/linux_auditd.py

@@ -52,6 +52,11 @@ DEFAULT_AUDIT_LOG = "/var/log/audit/audit.log"
 _UNSET = {"4294967295", "-1", "unset"}
 #: Records of one event share a serial; bound how many half-seen events we hold.
 _MAX_PENDING = 512
+#: An event whose records stopped arriving this long ago is complete. auditd 4.x
+#: (Ubuntu 26.04) writes NO `EOE` records at all, so this, `PROCTITLE` and the
+#: single-record user-space types are what close an event there. Mirrors auparse's
+#: own `eoe_timeout` (2 s by default).
+EOE_TIMEOUT_S = 2.0
 _MAX_PID_CACHE = 20_000
 #: ``acct`` values on a failed login that are placeholders, not an account name.
 _NOT_A_NAME = ("(unknown)", "(invalid user)", "?")
@@ -139,6 +144,7 @@ class AuditdParser:
         self._user_name = user_name
         self._book = book or SessionBook()
         self._pending: OrderedDict[str, dict[str, dict[str, str]]] = OrderedDict()
+        self._pending_ts: dict[str, float] = {}     # serial → event time
         self._ppid: OrderedDict[int, int] = OrderedDict()
         self._ses_key: dict[str, str] = {}   # auditd ses id → our session key
         self._ses_kind: dict[str, SessionKind] = {}
@@ -177,6 +183,15 @@ class AuditdParser:
             rec["_args"] = " ".join(args[i] for i in sorted(args))
 
         self._pending.setdefault(serial, {})[rtype] = rec
+        self._pending_ts.setdefault(serial, ts)
+        # Close the event as soon as it is known to be complete, rather than only on
+        # EOE: auditd 4.x never writes EOE, and an event held for one waited for up to
+        # 512 later events (a quiet box shipped nothing; a restart lost what was held).
+        if rtype.startswith("USER_") or rtype == "PROCTITLE":
+            # USER_* come from user space as one self-contained record; PROCTITLE is
+            # the kernel's last record of a syscall event.
+            self._finalize(serial)
+        self.flush_older_than(ts - EOE_TIMEOUT_S)
         while len(self._pending) > _MAX_PENDING:
             self._finalize(next(iter(self._pending)))
 
@@ -185,10 +200,21 @@ class AuditdParser:
         for serial in list(self._pending):
             self._finalize(serial)
 
+    def flush_older_than(self, cutoff: float) -> None:
+        """Finalize events whose time is before ``cutoff`` — their records are all in.
+
+        Called with the newest event time on every record, and with the wall clock by
+        the tail loop when the log is idle, so the last event before a quiet spell is
+        not held until the next one arrives.
+        """
+        for serial in [s for s, t in self._pending_ts.items() if t < cutoff]:
+            self._finalize(serial)
+
     # ── one event ────────────────────────────────────────────────────────────
 
     def _finalize(self, serial: str) -> None:
         recs = self._pending.pop(serial, None)
+        self._pending_ts.pop(serial, None)
         if not recs:
             return
         try:
@@ -396,9 +422,12 @@ class AuditdCollector:
                 for raw in data[:cut].splitlines():
                     self._parser.feed(raw.decode("utf-8", "replace"))
                 offset += cut
-                # No parser.flush() here: an event is finalized by its EOE record, and
-                # flushing mid-read could finalize one whose lines straddle two reads.
+                # No parser.flush() here: flushing mid-read could finalize an event whose
+                # lines straddle two reads. Only events older than EOE_TIMEOUT_S are
+                # closed below — their records are all in the log by then.
                 self._save(inode, offset)
+            # Wall-clock close for the last event before a quiet spell (no EOE on auditd 4.x).
+            self._parser.flush_older_than(time.time() - EOE_TIMEOUT_S)
             time.sleep(self._poll_s)
 
     def _load(self) -> tuple[int | None, int]:

{devops_bot_sdk-1.6.49 → devops_bot_sdk-1.6.52}/sdk/ui/server.py

@@ -140,7 +140,12 @@ def create_app():
 
     @app.get("/healthz")
     async def healthz():
-        return {"ok": True}
+        # `version` is what the updater compares against the installed SDK: a panel
+        # started before an upgrade keeps running the old code until it restarts,
+        # and "already up to date" on disk says nothing about the running process.
+        from sdk import __version__ as _v
+
+        return {"ok": True, "version": _v}
 
     # ── Swagger: public shell, token-gated schema ───────────────────────────────
     # Registered HERE, before the static mount below: Starlette matches in insertion

{devops_bot_sdk-1.6.49 → devops_bot_sdk-1.6.52}/sdk/ui/service.py

@@ -678,6 +678,71 @@ def refresh() -> tuple[bool, str]:
             else f"service definition regenerated ({host}:{port}) but restart needs attention: {rmsg}")
 
 
+def running_version(timeout: float = 3.0) -> str | None:
+    """The SDK version the RUNNING panel reports, from its own ``/healthz``.
+
+    ``""`` when it answers without a version (a panel older than this check: stale
+    by definition), ``None`` when it cannot be reached (unknown: do not act on it).
+    Loopback unless the panel was bound to one specific address.
+    """
+    import json
+    import urllib.request
+
+    host, port = _installed_host_port()
+    if host in ("0.0.0.0", "::", ""):
+        host = "127.0.0.1"
+    url = f"http://{'[' + host + ']' if ':' in host else host}:{port}/healthz"
+    try:
+        with urllib.request.urlopen(url, timeout=timeout) as resp:  # noqa: S310 — loopback/own panel
+            body = json.loads(resp.read().decode("utf-8", "replace") or "{}")
+    except Exception:  # noqa: BLE001 — not up yet, other port, IP gate …
+        return None
+    return str(body.get("version") or "")
+
+
+def _wait_for_version(want: str, attempts: int = 10, delay: float = 2.0) -> str | None:
+    """Poll the restarted panel until it answers; its version, or None if it never did."""
+    import time
+
+    seen: str | None = None
+    for _ in range(attempts):
+        seen = running_version()
+        if seen == want:
+            return seen
+        time.sleep(delay)
+    return seen
+
+
+def _restart_if_stale() -> tuple[bool, str] | None:
+    """Restart a running panel whose code is older than the installed SDK.
+
+    The gap this closes: when ``agentos-auto update`` finds the disk already current
+    it never restarted the panel, so a panel started BEFORE the upgrade landed (by
+    an earlier update run, a manual pip install, a second install) kept running the
+    old code indefinitely. On a VPS that meant the activity collector never started.
+    ``None`` when there is nothing to do (current, or the version is unknowable).
+    """
+    from sdk import __version__ as installed
+
+    running = running_version()
+    if running is None or running == installed:
+        return None
+    was = running or "a version older than 1.6.50"
+    rok, rmsg = refresh()
+    if not rok:
+        return False, f"panel runs {was} but {installed} is installed; restart failed: {rmsg}"
+    now = _wait_for_version(installed)
+    if now == installed:
+        return True, f"panel was running {was}; restarted on {installed}."
+    # Restarted, and STILL not this version: the service runs another installation
+    # (a different interpreter / prefix) that this updater did not touch.
+    unit = _service_definition_path()
+    return False, (f"panel restarted but reports {now or 'no version'}, not {installed}: the "
+                   f"service runs a different SDK installation than this one "
+                   f"({sys.executable}). Check the service definition"
+                   f"{f' ({unit})' if unit else ''} and update that installation.")
+
+
 def _service_disabled() -> bool:
     return os.environ.get("AGENTOS_NO_SERVICE", "").strip().lower() in ("1", "true", "yes", "on")
 
@@ -719,6 +784,10 @@ def ensure(restart_running: bool = False) -> tuple[bool, str]:
         rok, rmsg = refresh()
         return rok, (_with_token_warning(rmsg) if rok else rmsg)
     if _is_active():
+        stale = _restart_if_stale()
+        if stale is not None:
+            ok, msg = stale
+            return ok, (_with_token_warning(msg) if ok else msg)
         return True, _with_token_warning("service already running.")
     rok, rmsg = restart()                   # installed but down → bring it back up
     return rok, (_with_token_warning(f"service was down — started; {rmsg}") if rok else rmsg)

{devops_bot_sdk-1.6.49 → devops_bot_sdk-1.6.52}/sdk/ui/setup_manager.py

@@ -102,9 +102,12 @@ async def reinstall_sdk(upgrade: bool = True):
     which is the managed ``agentsystem`` venv in normal operation. Used by
     ``/setup`` for a repair/reinstall.
     """
+    from sdk.updater import _pip_flags
+
     argv = [sys.executable, "-m", "pip", "install"]
     if upgrade:
         argv.append("--upgrade")
+    argv += _pip_flags()
     argv.append(SDK_GIT_SPEC)
 
     yield f"$ {' '.join(argv)}\n"

{devops_bot_sdk-1.6.49 → devops_bot_sdk-1.6.52}/sdk/updater.py

@@ -8,7 +8,8 @@ Upgrade priority:
      (backend returns the user's stored GitHub OAuth token — no extra config)
   4. PyPI dist name as last resort
 
-Adds --break-system-packages automatically on Linux (Ubuntu 22.04+/Debian 12+).
+Adds --break-system-packages automatically on any externally-managed Python
+(PEP 668: Ubuntu 22.04+/Debian 12+, Homebrew Python on macOS).
 Disable entirely with AGENTOS_NO_UPDATE=1.
 """
 from __future__ import annotations
@@ -54,9 +55,35 @@ def _with_extras(target: str) -> str:
 
 # ── Platform helpers ──────────────────────────────────────────────────────────
 
+def _externally_managed() -> bool:
+    """True when pip will refuse this interpreter under PEP 668.
+
+    The marker is an ``EXTERNALLY-MANAGED`` file in the stdlib directory, and a
+    venv is exempt. Checking for it, rather than the OS, is what covers Homebrew
+    Python on macOS: a Mac VPS on ``/opt/homebrew/.../python3.14`` was refused on
+    every upgrade attempt and stayed on an old version indefinitely, because the
+    flag below used to be added on Linux only.
+    """
+    if sys.prefix != getattr(sys, "base_prefix", sys.prefix):
+        return False
+    try:
+        import sysconfig
+        return os.path.isfile(
+            os.path.join(sysconfig.get_path("stdlib"), "EXTERNALLY-MANAGED"))
+    except Exception:  # noqa: BLE001 — an unreadable layout is not "managed"
+        return False
+
+
 def _pip_flags() -> list[str]:
-    """--break-system-packages on Linux (PEP 668); empty elsewhere."""
-    return ["--break-system-packages"] if platform.system() == "Linux" else []
+    """--break-system-packages where PEP 668 applies; empty elsewhere.
+
+    Linux keeps the flag unconditionally, as before (every supported distro pip
+    accepts it). Elsewhere it is added only when the marker is present, since an
+    old pip that predates PEP 668 rejects the option outright.
+    """
+    if platform.system() == "Linux" or _externally_managed():
+        return ["--break-system-packages"]
+    return []
 
 
 def _vtuple(v: str) -> tuple:
@@ -589,7 +616,7 @@ def _report(result: UpgradeResult, latest: str | None) -> None:
             _say(f"    pip said: {result.detail}")
         _say("    fix it by hand with:\n"
              f'      "{sys.executable}" -m pip install --upgrade --force-reinstall '
-             f'--no-cache-dir "{_DIST}{_EXTRAS}"')
+             f'--no-cache-dir {" ".join(_pip_flags() + [""])}"{_DIST}{_EXTRAS}"')
         return
 
     if result.ran:

{devops_bot_sdk-1.6.49 → devops_bot_sdk-1.6.52}/sdk/vps_health.py

@@ -33,6 +33,7 @@ ping just waits for the next tick.
 from __future__ import annotations
 
 import asyncio
+import ipaddress
 import logging
 import os
 import socket
@@ -120,6 +121,21 @@ def _outbound_ip() -> str:
                 pass
 
 
+def _is_public(ip: str) -> bool:
+    """Only a globally-routable address may overwrite the allocation's IP.
+
+    Behind NAT (an AWS instance, a laptop on Wi-Fi) the route-to-internet address
+    is private — ``172.31.x.x``, ``192.168.x.x`` — and sending it replaced the
+    VPS's real public IP on ``contabo_allocation``, after which the backend could
+    no longer reach the panel at all. Omitting the key leaves the stored value
+    alone, the same rule every other unavailable metric here follows.
+    """
+    try:
+        return bool(ip) and ipaddress.ip_address(ip).is_global
+    except ValueError:
+        return False
+
+
 def _bandwidth_used_mb() -> float | None:
     """Total bytes in+out since boot, in MB. None when psutil is unavailable.
 
@@ -183,7 +199,7 @@ def build_payload(health: dict | None = None) -> dict:
         payload["bandwidthUsed"] = bw                                      # MB, cumulative
 
     ip = _outbound_ip()
-    if ip:
+    if _is_public(ip):
         payload["ipAddress"] = ip
 
     return payload

{devops_bot_sdk-1.6.49 → devops_bot_sdk-1.6.52}/tests/test_activity_collectors.py

@@ -647,3 +647,65 @@ class TestSetupAtPanelStart:
         async def go():
             await collectors.start()
         asyncio.run(go())
+
+
+class TestNoEoeRecords:
+    """auditd 4.x (Ubuntu 26.04) writes NO `EOE` records. The parser closed events only
+    on EOE (or after 512 more piled up), so a quiet VPS shipped nothing at all and a busy
+    one shipped ~10% of its commands, late, losing whatever was held at a restart."""
+
+    # Verbatim from a live Ubuntu 26.04 / auditctl 4.1.2 VPS (log_format = ENRICHED; the
+    # enriched tail is separated by \x1d), serial 761 — no EOE follows it.
+    JAVAID_EXEC = [
+        'type=SYSCALL msg=audit(1791570760.040:761): arch=c000003e syscall=59 success=yes exit=0 '
+        'a0=7bd5038c3130 a1=7bd5038c30d0 a2=7bd5038f77b0 a3=8 items=2 ppid=1387309 pid=1388791 '
+        'auid=4294967295 uid=0 gid=0 euid=0 suid=0 fsuid=0 egid=0 sgid=0 fsgid=0 tty=(none) '
+        'ses=4294967295 comm="auditctl" exe="/usr/sbin/auditctl" subj=unconfined '
+        'key="agentos_exec"\x1dARCH=x86_64 SYSCALL=execve AUID="unset" UID="root"',
+        'type=EXECVE msg=audit(1791570760.040:761): argc=2 a0="auditctl" a1="-l"',
+        'type=CWD msg=audit(1791570760.040:761): cwd="/root"',
+        'type=PATH msg=audit(1791570760.040:761): item=0 name="/usr/sbin/auditctl" inode=60036 '
+        'dev=fd:01 mode=0100755 ouid=0 ogid=0 rdev=00:00 nametype=NORMAL',
+        'type=PROCTITLE msg=audit(1791570760.040:761): proctitle=2F7573722F7362696E2F61756469746374'
+        '6C002D6C',
+    ]
+
+    def test_a_command_is_recorded_without_an_eoe_line(self):
+        p = _parser()
+        _feed(p, self.JAVAID_EXEC)
+        _, events = _queued()
+        assert [(e["action"], e["command"]) for e in events] == [("exec", "auditctl -l")]
+
+    def test_without_proctitle_the_event_closes_once_a_later_event_is_two_seconds_on(self):
+        p = _parser()
+        _feed(p, self.JAVAID_EXEC[:4])                         # no PROCTITLE, no EOE
+        assert _queued()[1] == []                              # may still be arriving
+        _feed(p, ['type=CWD msg=audit(1791570762.500:900): cwd="/"'])   # 2.46 s later
+        _, events = _queued()
+        assert [e["command"] for e in events] == ["auditctl -l"]
+
+    def test_the_idle_tail_closes_the_last_event_by_wall_clock(self):
+        p = _parser()
+        _feed(p, self.JAVAID_EXEC[:4])
+        assert _queued()[1] == []
+        p.flush_older_than(1791570760.040 + L.EOE_TIMEOUT_S + 0.1)
+        assert [e["command"] for e in _queued()[1]] == ["auditctl -l"]
+
+    def test_a_failed_login_is_recorded_on_its_own_record(self):
+        """USER_* records are single, self-contained user-space events: no EOE ever."""
+        p = _parser(user_name=L._default_user_name)
+        _feed(p, [
+            "type=USER_LOGIN msg=audit(1791568160.154:240124): pid=1828747 uid=0 "
+            "auid=4294967295 ses=4294967295 subj=unconfined msg='op=login "
+            "acct=\"root\" exe=\"/usr/lib/openssh/sshd-session\" "
+            "hostname=? addr=80.94.92.55 terminal=sshd res=failed'\x1dUID=\"root\" AUID=\"unset\"",
+        ])
+        _, events = _queued()
+        assert [(e["action"], e["osUser"], e["target"]) for e in events] == [
+            ("login.failed", "root", "80.94.92.55")]
+
+    def test_an_event_is_recorded_once_even_if_an_eoe_does_follow(self):
+        """Older auditd still writes EOE after PROCTITLE: no double record."""
+        p = _parser()
+        _feed(p, [*self.JAVAID_EXEC, "type=EOE msg=audit(1791570760.040:761): "])
+        assert len(_queued()[1]) == 1

devops_bot_sdk-1.6.52/tests/test_stale_panel_restart.py

@@ -0,0 +1,93 @@
+"""A panel started before an upgrade landed is restarted by the next update.
+
+Regression (2026-10-09, several VPSs): `agentos-auto update` said "already up to date
+(v1.6.49)" and `activity-setup --check` said "already set up", yet the box shipped no
+activity — the panel had been running since before the upgrade, on old code, and
+the "already current" path never restarted it.
+"""
+from unittest.mock import patch
+
+from sdk import __version__ as INSTALLED
+from sdk.ui import service
+
+
+def _ensure_running(monkeypatch, versions, refresh=(True, "service refreshed")):
+    """ensure() on an installed, active service; `versions` = successive /healthz answers."""
+    answers = iter(versions)
+    monkeypatch.setattr(service, "running_version", lambda timeout=3.0: next(answers, versions[-1]))
+    monkeypatch.setattr(service, "_wait_for_version",
+                        lambda want, attempts=10, delay=2.0: next(answers, versions[-1]))
+    calls = []
+
+    def fake_refresh():
+        calls.append("refresh")
+        return refresh
+
+    with patch.object(service, "_service_disabled", return_value=False), \
+         patch.object(service, "is_installed", return_value=True), \
+         patch.object(service, "update_timer_installed", return_value=True), \
+         patch.object(service, "_needs_root_for_existing", return_value=False), \
+         patch.object(service, "_is_active", return_value=True), \
+         patch.object(service, "_with_token_warning", side_effect=lambda m: m), \
+         patch.object(service, "refresh", side_effect=fake_refresh):
+        ok, msg = service.ensure()
+    return ok, msg, calls
+
+
+def test_a_current_panel_is_left_alone(monkeypatch):
+    ok, msg, calls = _ensure_running(monkeypatch, [INSTALLED])
+    assert calls == [] and ok and msg == "service already running."
+
+
+def test_an_older_panel_is_restarted_onto_the_installed_version(monkeypatch):
+    ok, msg, calls = _ensure_running(monkeypatch, ["1.6.44", INSTALLED])
+    assert calls == ["refresh"] and ok
+    assert "1.6.44" in msg and INSTALLED in msg
+
+
+def test_a_panel_too_old_to_report_a_version_is_stale(monkeypatch):
+    """Panels before this fix answer /healthz with no version at all."""
+    ok, msg, calls = _ensure_running(monkeypatch, ["", INSTALLED])
+    assert calls == ["refresh"] and ok
+
+
+def test_an_unreachable_panel_is_never_restarted_on_a_guess(monkeypatch):
+    ok, msg, calls = _ensure_running(monkeypatch, [None])
+    assert calls == [] and msg == "service already running."
+
+
+def test_still_old_after_restart_names_the_second_installation(monkeypatch):
+    """The VPS case where the service ran /usr/local python3.12 and the update had
+    upgraded a different install: say so instead of claiming success."""
+    ok, msg, calls = _ensure_running(monkeypatch, ["1.6.44", "1.6.44"])
+    assert calls == ["refresh"] and ok is False
+    assert "different SDK installation" in msg
+
+
+def test_a_failed_restart_is_reported(monkeypatch):
+    ok, msg, calls = _ensure_running(monkeypatch, ["1.6.44"], refresh=(False, "permission denied"))
+    assert ok is False and "permission denied" in msg
+
+
+def test_the_probe_reads_the_version_from_healthz(monkeypatch):
+    import io
+    import json
+
+    seen = {}
+
+    class Resp(io.BytesIO):
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *a):
+            return False
+
+    def fake_urlopen(url, timeout):
+        seen["url"] = url
+        return Resp(json.dumps({"ok": True, "version": "9.9.9"}).encode())
+
+    monkeypatch.undo()        # drop conftest's running_version stub: test the real probe
+    monkeypatch.setattr(service, "_installed_host_port", lambda: ("0.0.0.0", 8765))
+    monkeypatch.setattr("urllib.request.urlopen", fake_urlopen)
+    assert service.running_version() == "9.9.9"
+    assert seen["url"] == "http://127.0.0.1:8765/healthz"

{devops_bot_sdk-1.6.49 → devops_bot_sdk-1.6.52}/tests/test_ui_lifespan.py

@@ -99,4 +99,6 @@ class TestLifespanCrons:
         # Entering the context manager runs the REAL lifespan, so a cron that
         # raises there would surface as a failed startup rather than a served page.
         with TestClient(create_app()) as c:
-            assert c.get("/healthz").json() == {"ok": True}
+            from sdk import __version__
+            # `version` lets the updater spot a panel still running pre-upgrade code.
+            assert c.get("/healthz").json() == {"ok": True, "version": __version__}

devops_bot_sdk-1.6.52/tests/test_updater_pep668.py

@@ -0,0 +1,53 @@
+"""PEP 668 is a property of the interpreter, not of Linux.
+
+Homebrew Python on macOS ships an EXTERNALLY-MANAGED marker, and the updater
+used to add --break-system-packages on Linux only — so a Mac VPS was refused on
+every upgrade path and stayed on an old SDK indefinitely.
+"""
+from __future__ import annotations
+
+import sys
+
+from sdk import updater
+
+
+def _stdlib(monkeypatch, tmp_path, *, marker: bool, venv: bool = False):
+    import sysconfig
+    if marker:
+        (tmp_path / "EXTERNALLY-MANAGED").write_text("[externally-managed]\n")
+    monkeypatch.setattr(sysconfig, "get_path", lambda name: str(tmp_path))
+    monkeypatch.setattr(sys, "base_prefix", "/base" if venv else sys.prefix)
+
+
+def test_homebrew_macos_gets_the_flag(monkeypatch, tmp_path):
+    monkeypatch.setattr(updater.platform, "system", lambda: "Darwin")
+    _stdlib(monkeypatch, tmp_path, marker=True)
+    assert updater._pip_flags() == ["--break-system-packages"]
+
+
+def test_unmanaged_macos_python_does_not(monkeypatch, tmp_path):
+    """An old pip that predates PEP 668 rejects the option outright."""
+    monkeypatch.setattr(updater.platform, "system", lambda: "Darwin")
+    _stdlib(monkeypatch, tmp_path, marker=False)
+    assert updater._pip_flags() == []
+
+
+def test_a_venv_is_exempt(monkeypatch, tmp_path):
+    monkeypatch.setattr(updater.platform, "system", lambda: "Windows")
+    _stdlib(monkeypatch, tmp_path, marker=True, venv=True)
+    assert updater._pip_flags() == []
+
+
+def test_linux_keeps_the_flag_unconditionally(monkeypatch, tmp_path):
+    monkeypatch.setattr(updater.platform, "system", lambda: "Linux")
+    _stdlib(monkeypatch, tmp_path, marker=False)
+    assert updater._pip_flags() == ["--break-system-packages"]
+
+
+def test_the_hand_fix_hint_carries_the_flag(monkeypatch, tmp_path, capsys):
+    monkeypatch.setattr(updater.platform, "system", lambda: "Darwin")
+    _stdlib(monkeypatch, tmp_path, marker=True)
+    res = updater.UpgradeResult(before="1.6.44", after="1.6.44", changed=False,
+                               ran=True, detail="externally-managed-environment")
+    updater._report(res, latest="1.6.51")
+    assert "--break-system-packages" in capsys.readouterr().out

{devops_bot_sdk-1.6.49 → devops_bot_sdk-1.6.52}/tests/test_vps_health.py

@@ -73,7 +73,7 @@ class TestBuildPayload:
     def test_maps_every_field(self, monkeypatch):
         monkeypatch.delenv("AGENTOS_VPS_HEALTH_STATUS", raising=False)
         monkeypatch.setattr(vps_health, "_bandwidth_used_mb", lambda: 1024.5)
-        monkeypatch.setattr(vps_health, "_outbound_ip", lambda: "192.168.1.1")
+        monkeypatch.setattr(vps_health, "_outbound_ip", lambda: "77.68.16.238")
 
         p = vps_health.build_payload(_HEALTH)
 
@@ -85,7 +85,7 @@ class TestBuildPayload:
         assert p["diskUsage"] == 30.2
         assert p["totalDisk"] == 500.0
         assert p["bandwidthUsed"] == 1024.5
-        assert p["ipAddress"] == "192.168.1.1"
+        assert p["ipAddress"] == "77.68.16.238"
         assert p["uptimeSeconds"] == 86400
         # ISO-8601 with millis + Z, as the backend sample shows.
         assert p["lastPingedAt"].endswith("Z") and "T" in p["lastPingedAt"]
@@ -118,6 +118,15 @@ class TestBuildPayload:
                        "totalDisk", "uptimeSeconds", "bandwidthUsed", "ipAddress"):
             assert absent not in p
 
+    @pytest.mark.parametrize("ip", ["172.31.44.234", "192.168.18.16", "10.0.0.5",
+                                    "127.0.0.1", "not-an-ip"])
+    def test_a_private_ip_never_overwrites_the_allocation(self, monkeypatch, ip):
+        """Behind NAT the outbound address is private; sending it replaced the
+        VPS's public IP and left the backend unable to reach the panel."""
+        monkeypatch.setattr(vps_health, "_bandwidth_used_mb", lambda: None)
+        monkeypatch.setattr(vps_health, "_outbound_ip", lambda: ip)
+        assert "ipAddress" not in vps_health.build_payload(_HEALTH)
+
 
 class _FakeClient:
     def __init__(self, ok: bool = True) -> None: