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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.75
+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.75 → 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.75
+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.75 → 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
@@ -230,5 +231,6 @@ tests/test_url_access.py
 tests/test_vps_health.py
 tests/test_vps_only_reporting.py
 tests/test_windows_loop_identity.py
+tests/test_windows_panel_task.py
 tests/test_windows_task_paths.py
 tests/test_write_hook.py

{devops_bot_sdk-1.6.75 → 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.75
+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.75"   # 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.75 → 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.75 → 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.75 → 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.75 → devops_bot_sdk-1.6.79}/sdk/ui/service.py

@@ -410,20 +410,118 @@ def _uninstall_launchd() -> tuple[bool, str]:
 
 # ── Windows (Scheduled Task) ────────────────────────────────────────────────
 
+#: Written when Windows refused the logged-out (S4U) panel task, so ``ensure`` does
+#: not rebuild the task on every update only to be refused again.
+_S4U_REFUSED_MARKER = Path.home() / ".agentos" / "panel_task_s4u_refused"
+
+
+def _windows_account() -> str:
+    """``DOMAIN\\user`` for the task principal — the user whose ~/.agentos holds the token."""
+    import getpass
+
+    user = os.environ.get("USERNAME") or getpass.getuser()
+    domain = os.environ.get("USERDOMAIN") or os.environ.get("COMPUTERNAME") or ""
+    return f"{domain}\\{user}" if domain else user
+
+
+def _panel_task_xml(exe: str, args: str, home: str, account: str) -> str:
+    """Task Scheduler XML for the panel: runs whether or not anyone is signed in.
+
+    The old task was ``/SC ONLOGON`` with an interactive token, so the panel — and
+    with it the health ping, the activity collector and the shipper — stopped the
+    moment the user signed out of RDP. A VPS used all day then reported nothing
+    from sign-out until the next sign-in ("VPS not reporting since 8h ago").
+
+    * ``S4U`` logon: runs without a stored password, signed in or not. It has no
+      Windows network credentials, which the panel does not use (HTTPS only).
+    * Boot AND logon triggers: up after a reboot with nobody signed in, and started
+      again at sign-in if it was down.
+    * Restart on failure, no execution time limit (the default is 72 h).
+    * ``HighestAvailable``: the collector reads the Security log, which needs an
+      elevated token — same as the old ``/RL HIGHEST``.
+    """
+    from xml.sax.saxutils import escape
+
+    who = escape(account)
+    return (
+        '<?xml version="1.0" encoding="UTF-16"?>\n'
+        '<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">\n'
+        "  <RegistrationInfo><Description>AgentOS control panel (health, activity, "
+        "ticket runs)</Description></RegistrationInfo>\n"
+        "  <Triggers>\n"
+        "    <BootTrigger><Enabled>true</Enabled><Delay>PT1M</Delay></BootTrigger>\n"
+        f"    <LogonTrigger><Enabled>true</Enabled><UserId>{who}</UserId></LogonTrigger>\n"
+        "  </Triggers>\n"
+        f'  <Principals><Principal id="Author"><UserId>{who}</UserId>'
+        "<LogonType>S4U</LogonType><RunLevel>HighestAvailable</RunLevel>"
+        "</Principal></Principals>\n"
+        "  <Settings>\n"
+        "    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>\n"
+        "    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>\n"
+        "    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>\n"
+        "    <StartWhenAvailable>true</StartWhenAvailable>\n"
+        "    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>\n"
+        "    <RestartOnFailure><Interval>PT1M</Interval><Count>999</Count></RestartOnFailure>\n"
+        "  </Settings>\n"
+        '  <Actions Context="Author"><Exec>'
+        f"<Command>{escape(exe)}</Command><Arguments>{escape(args)}</Arguments>"
+        f"<WorkingDirectory>{escape(home)}</WorkingDirectory>"
+        "</Exec></Actions>\n"
+        "</Task>\n"
+    )
+
+
+def _create_task_from_xml(task: str, xml: str) -> tuple[int, str]:
+    import tempfile
+
+    fd, path = tempfile.mkstemp(suffix=".xml")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-16") as fh:   # schtasks /XML wants UTF-16
+            fh.write(xml)
+        return _run(["schtasks", "/Create", "/TN", task, "/XML", path, "/F"])
+    except OSError as exc:
+        return 1, str(exc)
+    finally:
+        try:
+            os.unlink(path)
+        except OSError:
+            pass
+
+
 def _install_schtask(host: str, port: int) -> tuple[bool, str]:
     exe = _exe()
     refusal = _require_absolute(exe, WIN_TASK)
     if refusal:
         return False, refusal
-    tr = f'"{exe}" --host {host} --port {port} --no-browser'
-    rc, out = _run(["schtasks", "/Create", "/TN", WIN_TASK, "/TR", tr,
-                    "/SC", "ONLOGON", "/RL", "HIGHEST", "/F"])
+    args = f"--host {host} --port {port} --no-browser"
+    rc, out = _create_task_from_xml(
+        WIN_TASK, _panel_task_xml(exe, args, str(Path.home()), _windows_account()))
+    if rc == 0:
+        try:
+            _S4U_REFUSED_MARKER.unlink()
+        except OSError:
+            pass
+        _run(["schtasks", "/Run", "/TN", WIN_TASK])
+        return True, (f"installed scheduled task '{WIN_TASK}' — runs whether or not anyone "
+                      f"is signed in, restarts on failure, and is running now.")
+
+    # Windows refused it (e.g. a policy denying "Log on as a batch job"). Fall back to
+    # the at-logon task: worse — it stops at sign-out — but never worse than before.
+    try:
+        _S4U_REFUSED_MARKER.parent.mkdir(parents=True, exist_ok=True)
+        _S4U_REFUSED_MARKER.write_text(out[-2000:], encoding="utf-8")
+    except OSError:
+        pass
+    tr = f'"{exe}" {args}'
+    rc, out2 = _run(["schtasks", "/Create", "/TN", WIN_TASK, "/TR", tr,
+                     "/SC", "ONLOGON", "/RL", "HIGHEST", "/F"])
     if rc != 0:
-        return False, f"schtasks create failed:\n{out}"
+        return False, f"schtasks create failed:\n{out}\n{out2}"
     _run(["schtasks", "/Run", "/TN", WIN_TASK])
     return True, (f"installed scheduled task '{WIN_TASK}' — starts at logon and is "
-                  f"running now.\n  For crash-restart and no-login start, mark the task "
-                  f"'Run whether user is logged on' + 'Restart on failure' in Task Scheduler.")
+                  f"running now. NOTE: Windows refused the run-while-signed-out task, so "
+                  f"the panel STOPS when you sign out — disconnect from RDP instead of "
+                  f"signing out. Reason: {out.strip()[-300:]}")
 
 
 def _update_task_xml(exe: str, home: str) -> str:
@@ -527,6 +625,19 @@ def _schtask_points_nowhere(task: str) -> bool:
     return cmd is not None and not (Path(cmd).is_absolute() and Path(cmd).is_file())
 
 
+def _schtask_runs_signed_out(task: str) -> bool | None:
+    """True when ``task`` keeps running after sign-out; ``None`` if it cannot be read."""
+    rc, out = _run(["schtasks", "/Query", "/TN", task, "/XML"])
+    if rc != 0:
+        return None
+    return bool(re.search(r"<LogonType>\s*(S4U|Password)\s*</LogonType>", out))
+
+
+def _panel_task_needs_upgrade() -> bool:
+    """An at-logon panel task (pre-1.6.76) that Windows has not already refused to replace."""
+    return _schtask_runs_signed_out(WIN_TASK) is False and not _S4U_REFUSED_MARKER.exists()
+
+
 def _uninstall_schtask() -> tuple[bool, str]:
     _run(["schtasks", "/Delete", "/TN", WIN_UPDATE_TASK, "/F"])
     _run(["schtasks", "/End", "/TN", WIN_TASK])
@@ -855,6 +966,10 @@ def ensure(restart_running: bool = False) -> tuple[bool, str]:
         rok, rmsg = refresh()               # rebuilds the task with an absolute path
         return rok, (_with_token_warning(f"panel task pointed at a missing program — "
                                          f"rebuilt; {rmsg}") if rok else rmsg)
+    if IS_WINDOWS and _panel_task_needs_upgrade():
+        rok, rmsg = refresh()               # at-logon task → runs while signed out
+        return rok, (_with_token_warning(f"panel task now runs while signed out; {rmsg}")
+                     if rok else rmsg)
     if _is_active():
         stale = _restart_if_stale()
         if stale is not None:

{devops_bot_sdk-1.6.75 → 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.75 → 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: