devops-bot-sdk 1.6.76__tar.gz → 1.6.79__tar.gz

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.79}/PKG-INFO

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

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.79}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.79}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -175,6 +175,7 @@ tests/test_epic_inherited_agent_id.py
 tests/test_epic_session_isolation.py
 tests/test_estimator.py
 tests/test_fallback_cli.py
+tests/test_fallback_cli_upgrade.py
 tests/test_firewall_open_on_update.py
 tests/test_formats.py
 tests/test_git_action.py

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.79}/sdk/__init__.py

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

@@ -1383,7 +1383,7 @@ def _browser_command(args: list[str]) -> None:
 # ── fallback ─────────────────────────────────────────────────────────────
 
 def _fallback_usage() -> None:
-    print("usage: agentos fallback install                 # where `ad` is, or how to install it")
+    print("usage: agentos fallback install                 # install `ad`, or update an outdated one")
     print("       agentos fallback login [--browser | --api-key [KEY]] [--base-url URL] [--no-browser]")
     print("       agentos fallback status [--verify]       # --verify asks the server too")
     print("       agentos fallback logout")
@@ -1411,8 +1411,11 @@ def _fallback_command(args: list[str]) -> None:
         if le._fallback_disabled():
             print("error: the fallback is disabled (AGENTOS_FALLBACK_CLI=off)")
             sys.exit(1)
-        # The SDK no longer installs the CLI: it is updated continuously, so the
-        # copy on the machine is the one to use. This only reports where it is.
+        # Installs the CLI when it is missing, and replaces an outdated one (the old
+        # package name, or a release older than FALLBACK_MIN_VERSION).
+        done = le.upgrade_fallback_cli(install_missing=True)
+        if done:
+            print(done)
         cli = le.fallback_cli_path()
         if not cli:
             print(f"error: the AI Draftsman CLI (`ad`) was not found. Install it with:\n"

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.79}/sdk/local_exec.py

@@ -24,6 +24,7 @@ import re
 import shutil
 import subprocess
 import sys
+import time
 from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Any, Awaitable, Callable
@@ -1047,7 +1048,7 @@ async def _run_claude_cli(
 # ── Fallback: the AI Draftsman CLI ─────────────────────────────────────────
 # When the `claude` CLI is not AVAILABLE — not installed, logged out, or dying
 # before it even starts a session — the ticket runs on our own AI Draftsman CLI
-# (`ad`, npm package @aidraftsman/cli) instead of failing or parking. It is the
+# (`ad`, npm package @consultancy-outfit/ai-draftsman-cli) instead of failing or parking. It is the
 # same job against the same project dir: the prompt goes in on stdin,
 # `-p --output-format json` prints one JSON object.
 #
@@ -1056,9 +1057,13 @@ async def _run_claude_cli(
 # model mid-ticket.
 #
 # The CLI is the one already installed on the machine (`ad` on PATH, or an npm
-# global bin dir the service's PATH may not include). The SDK never installs it:
-# it is updated continuously, and a copy pinned inside the SDK went stale the
-# day after it shipped. It needs its own login on the box, as the user the SDK
+# global bin dir the service's PATH may not include). The SDK does not pin a copy
+# (one pinned inside the SDK went stale the day after it shipped), but it does keep
+# an installed one current: an `ad` from the old package name, or older than
+# FALLBACK_MIN_VERSION, is replaced with the latest release (`upgrade_fallback_cli`).
+# Before 1.1.1 every request carried a tool schema Gemini rejects (an integer
+# `enum`), so an old `ad` failed every ticket with "400 INVALID_ARGUMENT …
+# function_declarations". It needs its own login on the box, as the user the SDK
 # runs as: `agentos fallback login` (browser sign-in code or an API key), or
 # AD_API_KEY in the env. `agentos fallback status --verify` checks it against
 # the server.
@@ -1089,8 +1094,15 @@ def _setting(key: str) -> str:
         return ""
 
 
+#: The npm package that ships `ad`. It was published as @aidraftsman/cli before 1.1.1.
+FALLBACK_PACKAGE = "@consultancy-outfit/ai-draftsman-cli"
+_LEGACY_FALLBACK_PACKAGES = ("@aidraftsman/cli",)
+#: The oldest `ad` that works against the gateway's Gemini models (see above).
+FALLBACK_MIN_VERSION = (1, 1, 1)
 #: How to get the CLI when it is missing — shown in every "not found" message.
-FALLBACK_INSTALL_HINT = "npm install -g @aidraftsman/cli"
+FALLBACK_INSTALL_HINT = f"npm install -g {FALLBACK_PACKAGE}"
+#: `upgrade_fallback_cli` runs at most this often from the start-up path.
+_FALLBACK_UPGRADE_EVERY_S = 6 * 3600
 
 
 def _fallback_disabled() -> bool:
@@ -1135,10 +1147,110 @@ def fallback_cli_path() -> str | None:
 
 
 async def ensure_fallback_cli() -> str | None:
-    """:func:`fallback_cli_path`. Kept for callers; it no longer installs anything."""
+    """:func:`fallback_cli_path`. Kept for callers; it installs nothing itself."""
     return fallback_cli_path()
 
 
+def _version_tuple(version: str) -> tuple[int, ...]:
+    parts = []
+    for piece in str(version).split("-")[0].split("."):
+        try:
+            parts.append(int(piece))
+        except ValueError:
+            break
+    return tuple(parts)
+
+
+def _npm_cmd(*args: str) -> list[str] | None:
+    """An npm command line, or None without npm. npm is a .cmd shim on Windows."""
+    npm = shutil.which("npm")
+    if not npm:
+        return None
+    cmd = [npm, *args]
+    if sys.platform == "win32" and npm.lower().endswith((".cmd", ".bat")):
+        cmd = [os.environ.get("COMSPEC", "cmd.exe"), "/c", *cmd]
+    return cmd
+
+
+def fallback_packages() -> dict[str, str]:
+    """The AI Draftsman CLI packages npm has installed globally, ``{name: version}``.
+
+    Read from npm rather than ``ad --version``: 1.1.1 still prints "1.1.0" there,
+    so the version flag cannot tell the fixed release from the broken one.
+    """
+    cmd = _npm_cmd("ls", "-g", "--depth=0", "--json")
+    if not cmd:
+        return {}
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True, errors="replace",
+                              timeout=60, check=False)
+        deps = (json.loads(proc.stdout or "{}") or {}).get("dependencies") or {}
+    except Exception:  # noqa: BLE001 — npm missing/slow/odd output: nothing known
+        return {}
+    wanted = (FALLBACK_PACKAGE, *_LEGACY_FALLBACK_PACKAGES)
+    return {name: str((deps.get(name) or {}).get("version") or "")
+            for name in wanted if name in deps}
+
+
+def upgrade_fallback_cli(*, install_missing: bool = False) -> str:
+    """Bring the AI Draftsman CLI up to date. Returns what was done, ``""`` if nothing.
+
+    Replaces an `ad` from the old package name and upgrades one older than
+    FALLBACK_MIN_VERSION to the latest release. A machine without the CLI is left
+    alone unless ``install_missing`` (``agentos fallback install``). Skipped when the
+    fallback is off or AGENTOS_FALLBACK_CLI points at a CLI the owner manages. Never raises.
+    """
+    if _fallback_disabled() or _setting("AGENTOS_FALLBACK_CLI"):
+        return ""
+    if not _npm_cmd("--version"):
+        return ""
+    installed = fallback_packages()
+    legacy = [p for p in _LEGACY_FALLBACK_PACKAGES if p in installed]
+    current = installed.get(FALLBACK_PACKAGE)
+    if not legacy and current and _version_tuple(current) >= FALLBACK_MIN_VERSION:
+        return ""
+    if not legacy and not current and not install_missing:
+        return ""
+    try:
+        for pkg in legacy:   # same `ad` bin: the old package must go first
+            subprocess.run(_npm_cmd("uninstall", "-g", pkg), capture_output=True,
+                           text=True, errors="replace", timeout=300, check=False)
+        proc = subprocess.run(_npm_cmd("install", "-g", f"{FALLBACK_PACKAGE}@latest"),
+                              capture_output=True, text=True, errors="replace",
+                              timeout=600, check=False)
+    except Exception as exc:  # noqa: BLE001
+        return f"could not update the AI Draftsman CLI: {exc} — run `{FALLBACK_INSTALL_HINT}`"
+    if proc.returncode != 0:
+        tail = (proc.stderr or proc.stdout or "").strip()[-300:]
+        return f"could not update the AI Draftsman CLI ({tail}) — run `{FALLBACK_INSTALL_HINT}`"
+    now = fallback_packages().get(FALLBACK_PACKAGE, "?")
+    before = current or (installed.get(legacy[0]) if legacy else "") or "not installed"
+    return f"AI Draftsman CLI updated {before} → {now}"
+
+
+def maybe_upgrade_fallback_cli() -> str:
+    """:func:`upgrade_fallback_cli`, at most every few hours (start-up path)."""
+    stamp = Path.home() / ".agentos" / "fallback-cli-checked"
+    try:
+        if time.time() - stamp.stat().st_mtime < _FALLBACK_UPGRADE_EVERY_S:
+            return ""
+    except OSError:
+        pass
+    message = upgrade_fallback_cli()
+    try:
+        stamp.parent.mkdir(parents=True, exist_ok=True)
+        stamp.touch()
+    except OSError:
+        pass
+    return message
+
+
+def _is_stale_fallback_error(text: str | None) -> bool:
+    """The gateway rejected `ad`'s own tool schema — an outdated CLI, not the task."""
+    t = text or ""
+    return "INVALID_ARGUMENT" in t and "function_declarations" in t
+
+
 def _fallback_argv(cli: str, *args: str) -> list[str]:
     # npm installs a .cmd shim on Windows — same reason as the claude spawn.
     cmd = [cli, *args]
@@ -1325,8 +1437,13 @@ async def run_fallback_cli(
     extra_env: dict[str, str] | None = None,
     tier: str | None = None,
     provider: str | None = None,
+    _upgraded: bool = False,
 ) -> dict[str, Any]:
-    """Run ``prompt`` on the AI Draftsman CLI. Same result shape as the claude run."""
+    """Run ``prompt`` on the AI Draftsman CLI. Same result shape as the claude run.
+
+    An outdated `ad` fails its first request (its tool schema is rejected) before
+    touching anything, so that one failure upgrades the CLI and runs again, once.
+    """
     cli = await ensure_fallback_cli()
     if not cli:
         return _result(ok=False, error="AI Draftsman CLI (`ad`) not found on this "
@@ -1392,6 +1509,17 @@ async def run_fallback_cli(
             continue
     if proc.returncode != 0 or not isinstance(data, dict) or "result" not in data:
         err = err_text[-500:] or f"aidraftsman exited with code {proc.returncode}"
+        if _is_stale_fallback_error(err) and not _upgraded:
+            print("aidraftsman rejected its own tool list — the CLI is outdated; updating it",
+                  flush=True)
+            done = await asyncio.to_thread(upgrade_fallback_cli)
+            if done:
+                print(done, flush=True)
+            if done.startswith("AI Draftsman CLI updated"):
+                return await run_fallback_cli(
+                    prompt, project_path, timeout=timeout, github_token=github_token,
+                    extra_env=extra_env, tier=tier, provider=provider, _upgraded=True)
+            err += f" — the AI Draftsman CLI is outdated; run `{FALLBACK_INSTALL_HINT}`"
         auth_expired = proc.returncode == 2 or _is_auth_error(err)
         if auth_expired:
             err += " — log the fallback in with `agentos fallback login`"

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.79}/sdk/run_auto.py

@@ -1310,13 +1310,15 @@ def main() -> None:
         # report before → after. Does NOT start, stop, or touch the running loop —
         # a running daemon keeps its current code until it is restarted. Honours
         # AGENTOS_NO_UPDATE=1 (auto_update no-ops).
-        from sdk.updater import auto_update, current_version
-        before = current_version()
-        print("checking for SDK updates …")
-        auto_update(quiet=True)
-        after = current_version()
-        if after != before:
-            print(f"✓ updated {before} → {after}")
+        from sdk.updater import auto_update
+        # NOT quiet: auto_update's own report is the only honest answer. Quiet, a
+        # failed pip (a locked .exe on Windows, no network, …) left the version
+        # unchanged and this command printed "already up to date" — so boxes sat
+        # on 1.6.51 / 1.6.73 for days while PyPI had newer, and nobody could tell.
+        # The report says "still on vX — vY is published", quotes pip's error and
+        # prints the manual fix command.
+        changed, before, after = auto_update(quiet=False)
+        if changed:
             # Reload the control-panel server so newly-added /api/ui/* routes take
             # effect — a running server keeps the code it imported at boot. Only
             # restarts a managed (systemd/launchd/schtask) service; a manually-run
@@ -1338,8 +1340,6 @@ def main() -> None:
             if pid:
                 print("note: a background loop is running the OLD version — "
                       "`agentos-auto stop` then `agentos-auto` to run the new one.")
-        else:
-            print(f"already up to date (v{after})")
 
         # One-time GitHub history backfill — the last 50 days of THIS user's PRs.
         # Fired from `update` because that is the moment every machine passes

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.79}/sdk/updater.py

@@ -564,6 +564,9 @@ def auto_update(quiet: bool = False) -> tuple[bool, str, str | None]:
     """
     cur = current_version()
     if os.getenv("AGENTOS_NO_UPDATE"):
+        if not quiet:
+            _say(f"⚠ updates are switched off (AGENTOS_NO_UPDATE is set) — staying on v{cur}. "
+                 "Remove it from the environment / ~/.agentos/.env to update.")
         return (False, cur, None)
 
     latest = latest_pypi_version()
@@ -573,6 +576,13 @@ def auto_update(quiet: bool = False) -> tuple[bool, str, str | None]:
     # Nothing to do on a PyPI install that is already at (or past) the published
     # version — a git install still checks its branch, which PyPI cannot answer for.
     if not is_github and not behind_pypi:
+        if not quiet:
+            if latest:
+                _say(f"✓ already up to date (v{cur}).")
+            else:
+                # Not "up to date": we never found out. Saying so is the difference
+                # between a box that is current and one that cannot reach PyPI.
+                _say(f"⚠ could not reach PyPI to check for updates — staying on v{cur}.")
         audit_changed = _ensure_activity_audit(quiet)
         # Already current — just self-heal the service, restarting only if the
         # audit setup changed something the running panel must pick up.
@@ -637,6 +647,13 @@ def auto_update_and_reexec(module: str, argv: list[str]) -> None:
     if os.getenv("AGENTOS_NO_UPDATE") or os.getenv("_AGENTOS_REEXEC"):
         return
     updated, _cur, _latest = auto_update(quiet=False)
+    try:
+        from sdk.local_exec import maybe_upgrade_fallback_cli
+        fallback_note = maybe_upgrade_fallback_cli()
+        if fallback_note:
+            _say(("✓ " if fallback_note.startswith("AI Draftsman CLI updated") else "⚠ ") + fallback_note)
+    except Exception:  # noqa: BLE001 — the fallback CLI must never block a run
+        pass
 
     # A self-upgrade of a RUNNING package can land broken on Windows (the active
     # agentos-auto.exe / loaded files can't be replaced mid-pip — pip uninstalls
@@ -659,8 +676,13 @@ def auto_update_and_reexec(module: str, argv: list[str]) -> None:
     if not updated:
         return
     _say("restarting on the updated version …\n")
-    result = subprocess.run(
-        [sys.executable, "-m", module, *argv],
-        env={**os.environ, "_AGENTOS_REEXEC": "1"},
-    )
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", module, *argv],
+            env={**os.environ, "_AGENTOS_REEXEC": "1"},
+        )
+    except KeyboardInterrupt:
+        # Ctrl+C reaches the child too, which stops cleanly and says how to resume;
+        # the parent only waits for it, so it leaves without a traceback.
+        sys.exit(130)
     sys.exit(result.returncode)

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.79}/sdk/vps_identity.py

@@ -40,6 +40,11 @@ logger = logging.getLogger("sdk.vps_identity")
 #: A machine does not change into (or out of) a VPS often; a definite answer is
 #: reused this long so a 5-minute shipper does not fetch the profile every tick.
 CACHE_TTL_S = 6 * 3600.0
+#: A "no" is re-asked much sooner. The usual "no" is "no VPS is assigned to this
+#: user" on a box set up before its allocation existed — and holding that for 6 h
+#: kept a freshly assigned VPS silent (no health, activity discarded) for the rest
+#: of the working day. Re-asking costs one profile GET every few minutes.
+NEGATIVE_CACHE_TTL_S = 10 * 60.0
 
 _TRUTHY = {"1", "true", "yes", "on"}
 _FALSEY = {"0", "false", "no", "off"}
@@ -146,7 +151,8 @@ async def is_assigned_vps(client: "BackendClient | None" = None) -> bool | None:
     if forced is not None:
         return forced
     now = time.monotonic()
-    if _cache["value"] is not None and now - _cache["at"] < CACHE_TTL_S:
+    ttl = CACHE_TTL_S if _cache["value"] else NEGATIVE_CACHE_TTL_S
+    if _cache["value"] is not None and now - _cache["at"] < ttl:
         return _cache["value"]
     try:
         if client is None:

devops_bot_sdk-1.6.79/tests/test_fallback_cli_upgrade.py

@@ -0,0 +1,147 @@
+"""An outdated AI Draftsman CLI is replaced, not left to fail every ticket.
+
+Before 1.1.1 `ad` sent a tool schema Gemini rejects (an integer `enum` in
+create_artifact), so every fallback run died on its first request with
+"400 INVALID_ARGUMENT … function_declarations[5]". The fix shipped under a new npm
+name, and machines kept the old CLI: the SDK used whatever was installed.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import subprocess
+import sys
+
+import pytest
+
+from sdk import local_exec, updater
+
+_STALE = ("API error: INVALID_REQUEST: 400 INVALID_ARGUMENT Invalid value at "
+          "'tools[0].function_declarations[5].parameters.properties[8].value' (TYPE_STRING), 1")
+
+
+@pytest.fixture()
+def npm(monkeypatch):
+    """A scripted npm: `installed` is what `npm ls -g` reports; calls are recorded."""
+    state = {"installed": {}, "calls": [], "install_rc": 0}
+    monkeypatch.delenv("AGENTOS_FALLBACK_CLI", raising=False)
+    monkeypatch.setattr(local_exec, "_setting", lambda key: "")
+    monkeypatch.setattr(local_exec, "_npm_cmd", lambda *a: ["npm", *a])
+
+    def run(cmd, **kw):
+        args = cmd[1:]
+        state["calls"].append(args)
+        out, rc = "", 0
+        if args[:2] == ["ls", "-g"]:
+            out = json.dumps({"dependencies": {k: {"version": v} for k, v in state["installed"].items()}})
+        elif args[:2] == ["uninstall", "-g"]:
+            state["installed"].pop(args[2], None)
+        elif args[:2] == ["install", "-g"]:
+            rc = state["install_rc"]
+            if rc == 0:
+                state["installed"][local_exec.FALLBACK_PACKAGE] = "1.1.1"
+        return subprocess.CompletedProcess(cmd, rc, out, "EACCES" if rc else "")
+
+    monkeypatch.setattr(local_exec.subprocess, "run", run)
+    return state
+
+
+def _changes(state):
+    return [c for c in state["calls"] if c[0] in ("install", "uninstall")]
+
+
+class TestUpgrade:
+    def test_old_package_name_is_replaced(self, npm):
+        npm["installed"] = {"@aidraftsman/cli": "1.0.1"}
+        msg = local_exec.upgrade_fallback_cli()
+        assert _changes(npm) == [["uninstall", "-g", "@aidraftsman/cli"],
+                                 ["install", "-g", f"{local_exec.FALLBACK_PACKAGE}@latest"]]
+        assert msg == "AI Draftsman CLI updated 1.0.1 → 1.1.1"
+
+    def test_an_old_release_is_upgraded(self, npm):
+        npm["installed"] = {local_exec.FALLBACK_PACKAGE: "1.1.0"}
+        assert local_exec.upgrade_fallback_cli().startswith("AI Draftsman CLI updated 1.1.0")
+
+    def test_a_current_release_is_left_alone(self, npm):
+        npm["installed"] = {local_exec.FALLBACK_PACKAGE: "1.2.0"}
+        assert local_exec.upgrade_fallback_cli() == ""
+        assert _changes(npm) == []
+
+    def test_never_installs_unasked(self, npm):
+        assert local_exec.upgrade_fallback_cli() == ""
+        assert _changes(npm) == []
+
+    def test_install_missing_installs(self, npm):
+        assert local_exec.upgrade_fallback_cli(install_missing=True).endswith("→ 1.1.1")
+
+    def test_a_failed_npm_says_how_to_do_it_by_hand(self, npm):
+        npm["installed"] = {"@aidraftsman/cli": "1.0.1"}
+        npm["install_rc"] = 1
+        msg = local_exec.upgrade_fallback_cli()
+        assert "could not update" in msg and local_exec.FALLBACK_INSTALL_HINT in msg
+
+    def test_an_owner_managed_cli_is_not_touched(self, npm, monkeypatch):
+        npm["installed"] = {"@aidraftsman/cli": "1.0.1"}
+        monkeypatch.setattr(local_exec, "_setting",
+                            lambda key: "/opt/ad" if key == "AGENTOS_FALLBACK_CLI" else "")
+        assert local_exec.upgrade_fallback_cli() == ""
+        assert npm["calls"] == []
+
+    def test_start_up_check_runs_at_most_every_few_hours(self, npm, monkeypatch, tmp_path):
+        monkeypatch.setattr(local_exec.Path, "home", lambda: tmp_path)
+        npm["installed"] = {local_exec.FALLBACK_PACKAGE: "1.2.0"}
+        local_exec.maybe_upgrade_fallback_cli()
+        local_exec.maybe_upgrade_fallback_cli()
+        assert sum(1 for c in npm["calls"] if c[0] == "ls") == 1
+
+    def test_hint_names_the_new_package(self):
+        assert "@consultancy-outfit/ai-draftsman-cli" in local_exec.FALLBACK_INSTALL_HINT
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="POSIX script stand-in")
+class TestSelfHeal:
+    def _cli(self, tmp_path):
+        """Fails like an outdated `ad` on its first run, succeeds on the second."""
+        count = tmp_path / "runs"
+        script = tmp_path / "ad"
+        script.write_text(f"""#!{sys.executable}
+import json, sys, pathlib
+sys.stdin.read()
+p = pathlib.Path({str(count)!r}); n = int(p.read_text()) if p.exists() else 0; p.write_text(str(n + 1))
+if n == 0:
+    sys.stderr.write({_STALE!r}); sys.exit(1)
+print(json.dumps({{"result": "done", "usage": {{}}}}))
+""")
+        script.chmod(0o755)
+        return script, count
+
+    def test_upgrades_once_and_runs_again(self, tmp_path, monkeypatch):
+        cli, count = self._cli(tmp_path)
+        monkeypatch.setattr(local_exec, "fallback_cli_path", lambda: str(cli))
+        monkeypatch.setattr(local_exec, "upgrade_fallback_cli",
+                            lambda **k: "AI Draftsman CLI updated 1.0.1 → 1.1.1")
+        res = asyncio.run(local_exec.run_fallback_cli("x", str(tmp_path / "p")))
+        assert res["ok"] is True and count.read_text() == "2"
+
+    def test_no_upgrade_means_no_retry_and_a_clear_error(self, tmp_path, monkeypatch):
+        cli, count = self._cli(tmp_path)
+        monkeypatch.setattr(local_exec, "fallback_cli_path", lambda: str(cli))
+        monkeypatch.setattr(local_exec, "upgrade_fallback_cli", lambda **k: "")
+        res = asyncio.run(local_exec.run_fallback_cli("x", str(tmp_path / "p")))
+        assert res["ok"] is False and count.read_text() == "1"
+        assert "outdated" in res["error"] and local_exec.FALLBACK_INSTALL_HINT in res["error"]
+
+
+def test_ctrl_c_while_waiting_for_the_restarted_run_exits_quietly(monkeypatch):
+    monkeypatch.delenv("AGENTOS_NO_UPDATE", raising=False)
+    monkeypatch.delenv("_AGENTOS_REEXEC", raising=False)
+    monkeypatch.setattr(updater, "auto_update", lambda quiet=False: (True, "1", "2"))
+    monkeypatch.setattr(updater, "_verify_install", lambda: True)
+    monkeypatch.setattr(local_exec, "maybe_upgrade_fallback_cli", lambda: "")
+
+    def interrupted(*a, **k):
+        raise KeyboardInterrupt
+    monkeypatch.setattr(updater.subprocess, "run", interrupted)
+    with pytest.raises(SystemExit) as exc:
+        updater.auto_update_and_reexec("sdk.run_auto", ["ticket", "WEL-9"])
+    assert exc.value.code == 130

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.79}/tests/test_updater_reports_the_truth.py

@@ -257,6 +257,29 @@ class TestReporting:
         assert "could not check" in text
         assert "publickey" in text
 
+    def test_a_current_pypi_install_says_so(self):
+        _updated, said = self._run(installed="1.6.75", pypi="1.6.75", result=None,
+                                   is_github=False)
+        assert "already up to date (v1.6.75)" in "\n".join(said)
+
+    def test_unreachable_pypi_is_not_called_up_to_date(self):
+        """A PyPI install that cannot reach PyPI never found out — say that."""
+        _updated, said = self._run(installed="1.6.73", pypi=None, result=None,
+                                   is_github=False)
+        text = "\n".join(said)
+        assert "already up to date" not in text
+        assert "could not reach PyPI" in text
+
+    def test_updates_switched_off_is_said_out_loud(self, monkeypatch):
+        """AGENTOS_NO_UPDATE used to return silently, which the update command
+        then printed as "already up to date"."""
+        monkeypatch.setenv("AGENTOS_NO_UPDATE", "1")
+        said: list[str] = []
+        with patch.object(updater, "current_version", return_value="1.6.51"), \
+             patch.object(updater, "_say", said.append):
+            updater.auto_update(quiet=False)
+        assert "AGENTOS_NO_UPDATE" in "\n".join(said)
+
     def test_quiet_says_nothing_at_all(self):
         result = updater.UpgradeResult(False, "1.4.0", "1.4.0", True, "no-op")
         said: list[str] = []
@@ -326,3 +349,37 @@ class TestPipInstall:
 ])
 def test_failure_labels_name_the_source_without_leaking_it(url, label):
     assert updater._source_label(url) == label
+
+
+# ── `agentos-auto update`: the command must not override the report ───
+class TestUpdateCommand:
+    """The command called ``auto_update(quiet=True)`` and then printed its own
+    "already up to date" whenever the version had not moved — so a failed pip
+    (Mubashar's 1.6.73 box with 1.6.75 published, Tauqeer's 1.6.51 box) read as
+    current, and the report above was never shown to anyone."""
+
+    def _run_update(self, monkeypatch, capsys, result):
+        from sdk import run_auto
+
+        calls: list[bool] = []
+
+        def fake_auto_update(quiet=False):
+            calls.append(quiet)
+            return result
+        monkeypatch.setattr(updater, "auto_update", fake_auto_update)
+        monkeypatch.setattr(sys, "argv", ["agentos-auto", "update"])
+        monkeypatch.setattr(run_auto, "_daemon_running", lambda: None)
+        import sdk.github_ingest as gi
+        monkeypatch.setattr(gi, "run_backfill_once", lambda: {"ran": False})
+        import sdk.vps_health as vh
+        monkeypatch.setattr(vh, "enabled", lambda: False)
+        run_auto.main()
+        return calls, capsys.readouterr().out
+
+    def test_it_asks_for_the_full_report(self, monkeypatch, capsys):
+        calls, _ = self._run_update(monkeypatch, capsys, (False, "1.6.73", None))
+        assert calls == [False]
+
+    def test_it_never_prints_its_own_up_to_date(self, monkeypatch, capsys):
+        _, out = self._run_update(monkeypatch, capsys, (False, "1.6.73", None))
+        assert "already up to date" not in out

{devops_bot_sdk-1.6.76 → devops_bot_sdk-1.6.79}/tests/test_vps_only_reporting.py

@@ -91,6 +91,33 @@ class TestIsAssignedVps:
             assert asyncio.run(vps_identity.is_assigned_vps(client)) is True
         assert client.profile_calls == 1
 
+    def test_a_newly_assigned_vps_is_picked_up_within_minutes(self, monkeypatch):
+        """agentos installed BEFORE the allocation existed: the first answer is
+        "no VPS assigned". Cached for 6 h, that kept a freshly assigned VPS silent
+        — no health, activity discarded — for the rest of the day."""
+        _holds(monkeypatch, "217.160.157.148")
+        clock = {"t": 1000.0}
+        monkeypatch.setattr(vps_identity.time, "monotonic", lambda: clock["t"])
+
+        before = _Client(assigned="")
+        assert asyncio.run(vps_identity.is_assigned_vps(before)) is False
+        after = _Client(assigned="217.160.157.148")
+        clock["t"] += 60
+        assert asyncio.run(vps_identity.is_assigned_vps(after)) is False      # still cached
+        clock["t"] += vps_identity.NEGATIVE_CACHE_TTL_S
+        assert asyncio.run(vps_identity.is_assigned_vps(after)) is True       # re-asked
+        assert vps_identity.NEGATIVE_CACHE_TTL_S <= 15 * 60
+
+    def test_a_yes_is_still_cached_for_hours(self, monkeypatch):
+        _holds(monkeypatch, "77.68.23.23")
+        clock = {"t": 1000.0}
+        monkeypatch.setattr(vps_identity.time, "monotonic", lambda: clock["t"])
+        client = _Client()
+        asyncio.run(vps_identity.is_assigned_vps(client))
+        clock["t"] += vps_identity.NEGATIVE_CACHE_TTL_S * 3
+        asyncio.run(vps_identity.is_assigned_vps(client))
+        assert client.profile_calls == 1
+
     @pytest.mark.parametrize("raw, want", [("1", True), ("true", True), ("0", False), ("off", False)])
     def test_override_wins_without_a_profile_call(self, monkeypatch, raw, want):
         monkeypatch.setenv("AGENTOS_IS_VPS", raw)