devops-bot-sdk 1.6.66__tar.gz → 1.6.68__tar.gz

{devops_bot_sdk-1.6.66 → devops_bot_sdk-1.6.68}/PKG-INFO

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

{devops_bot_sdk-1.6.66 → devops_bot_sdk-1.6.68}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.66 → devops_bot_sdk-1.6.68}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -224,4 +224,5 @@ tests/test_updater_reports_the_truth.py
 tests/test_url_access.py
 tests/test_vps_health.py
 tests/test_windows_loop_identity.py
+tests/test_windows_task_paths.py
 tests/test_write_hook.py

{devops_bot_sdk-1.6.66 → devops_bot_sdk-1.6.68}/sdk/__init__.py

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

@@ -33,25 +33,65 @@ WIN_TASK = "AgentOS Control Panel"    # Windows scheduled-task name
 WIN_UPDATE_TASK = "AgentOS Self-Update"  # Windows counterpart of agentos-update.timer
 
 
+def _script_dirs() -> list[Path]:
+    """Where pip puts console scripts for THIS interpreter, most specific first.
+
+    Next to the interpreter covers a venv (``bin/`` / ``Scripts\\`` holds both
+    ``python`` and the scripts). It does NOT cover a regular Windows install, where
+    ``python.exe`` sits in the install root and the scripts in its ``Scripts\\``
+    subfolder — ``sysconfig``'s ``scripts`` path is the one that knows. The user
+    scheme covers a ``pip install --user``.
+    """
+    import sysconfig
+
+    dirs = [Path(sys.executable).parent]
+    for args in (("scripts",), ("scripts", f"{os.name}_user")):
+        try:
+            p = sysconfig.get_path(*args)
+        except KeyError:   # scheme not defined on this platform
+            continue
+        if p and Path(p) not in dirs:
+            dirs.append(Path(p))
+    return dirs
+
+
+def _console_script(base: str) -> str | None:
+    """ABSOLUTE path to this SDK's ``base`` console script, or ``None`` if not found."""
+    name = f"{base}.exe" if IS_WINDOWS else base
+    for d in _script_dirs():
+        cand = d / name
+        if cand.exists():
+            return str(cand)
+    found = shutil.which(name)
+    return str(Path(found).resolve()) if found else None
+
+
 def _exe() -> str:
     """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).
+    Must be absolute: a service manager (systemd/launchd/Task Scheduler) does NOT
+    search the user's PATH, 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 — and with 0x80070002 (file not found) on Windows, where
+    it lives in ``<python>\\Scripts``. Resolved via :func:`_console_script`; the
+    bare name is a last resort kept so a systemd install never hard-fails. The
+    Windows installers refuse it (see :func:`_require_absolute`).
     """
-    name = "agentos-ui.exe" if IS_WINDOWS else "agentos-ui"
-    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
+    return _console_script("agentos-ui") or ("agentos-ui.exe" if IS_WINDOWS else "agentos-ui")
+
+
+def _require_absolute(exe: str, task: str) -> str | None:
+    """Refusal message when ``exe`` is not an absolute path, else ``None``.
+
+    A scheduled task with a bare program name is created without complaint and then
+    never starts — Last Result 0x80070002, no panel, no activity trail, nothing on
+    screen. Refusing here turns that silence into a message the updater prints.
+    """
+    if Path(exe).is_absolute():
+        return None
+    return (f"not creating task '{task}': could not find {exe} for this Python "
+            f"({sys.executable}). Reinstall the SDK with that interpreter and re-run "
+            f"`agentos-auto update`.")
 
 
 def _run(argv: list[str]) -> tuple[int, str]:
@@ -169,10 +209,7 @@ def _auto_exe() -> str:
     minimal environment, and picking up a different venv's console script is how
     an updater ends up upgrading the wrong installation.
     """
-    candidate = Path(sys.executable).parent / ("agentos-auto.exe" if IS_WINDOWS else "agentos-auto")
-    if candidate.exists():
-        return str(candidate)
-    return shutil.which("agentos-auto") or "agentos-auto"
+    return _console_script("agentos-auto") or ("agentos-auto.exe" if IS_WINDOWS else "agentos-auto")
 
 
 def update_timer_installed() -> bool:
@@ -374,7 +411,11 @@ def _uninstall_launchd() -> tuple[bool, str]:
 # ── Windows (Scheduled Task) ────────────────────────────────────────────────
 
 def _install_schtask(host: str, port: int) -> tuple[bool, str]:
-    tr = f'"{_exe()}" --host {host} --port {port} --no-browser'
+    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"])
     if rc != 0:
@@ -440,7 +481,11 @@ def _install_update_schtask() -> tuple[bool, str]:
     """
     import tempfile
 
-    xml = _update_task_xml(_auto_exe(), str(Path.home()))
+    exe = _auto_exe()
+    refusal = _require_absolute(exe, WIN_UPDATE_TASK)
+    if refusal:
+        return False, refusal
+    xml = _update_task_xml(exe, str(Path.home()))
     fd, path = tempfile.mkstemp(suffix=".xml")
     try:
         with os.fdopen(fd, "w", encoding="utf-16") as fh:   # schtasks /XML wants UTF-16
@@ -459,6 +504,29 @@ def _install_update_schtask() -> tuple[bool, str]:
                   f"daily, randomized, catches up after downtime")
 
 
+def _schtask_command(task: str) -> str | None:
+    """The program ``task`` runs, from its XML definition; ``None`` if unreadable."""
+    import html
+
+    rc, out = _run(["schtasks", "/Query", "/TN", task, "/XML"])
+    if rc != 0:
+        return None
+    m = re.search(r"<Command>(.*?)</Command>", out, re.S)
+    return html.unescape(m.group(1)).strip().strip('"') if m else None
+
+
+def _schtask_points_nowhere(task: str) -> bool:
+    """True when ``task`` exists but runs a program that is not an existing file.
+
+    Boxes installed before :func:`_script_dirs` existed have a panel task whose
+    program is the bare ``agentos-ui.exe``. It shows "Ready", never runs, and the
+    ordinary update path ("installed + unchanged") only ever re-runs it — so without
+    this check those boxes would stay broken through every update.
+    """
+    cmd = _schtask_command(task)
+    return cmd is not None and not (Path(cmd).is_absolute() and Path(cmd).is_file())
+
+
 def _uninstall_schtask() -> tuple[bool, str]:
     _run(["schtasks", "/Delete", "/TN", WIN_UPDATE_TASK, "/F"])
     _run(["schtasks", "/End", "/TN", WIN_TASK])
@@ -771,7 +839,7 @@ def ensure(restart_running: bool = False) -> tuple[bool, str]:
     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 not update_timer_installed():
+    if not update_timer_installed() or (IS_WINDOWS and _schtask_points_nowhere(WIN_UPDATE_TASK)):
         _install_update_timer()
     if _needs_root_for_existing():
         return False, ("a system service is installed — run `sudo agentos-ui install` "
@@ -783,6 +851,10 @@ def ensure(restart_running: bool = False) -> tuple[bool, str]:
     if restart_running:
         rok, rmsg = refresh()
         return rok, (_with_token_warning(rmsg) if rok else rmsg)
+    if IS_WINDOWS and _schtask_points_nowhere(WIN_TASK):
+        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_active():
         stale = _restart_if_stale()
         if stale is not None:

{devops_bot_sdk-1.6.66 → devops_bot_sdk-1.6.68}/tests/test_update_timer.py

@@ -177,6 +177,7 @@ class TestWindowsUpdateTask:
 
     def test_creates_the_task_from_a_utf16_xml_file(self, monkeypatch):
         monkeypatch.setattr(service, "IS_WINDOWS", True)
+        monkeypatch.setattr(service, "_auto_exe", lambda: "/py/Scripts/agentos-auto.exe")
         seen = {}
 
         def fake_run(argv):
@@ -194,6 +195,7 @@ class TestWindowsUpdateTask:
 
     def test_a_failed_create_is_reported_not_raised(self, monkeypatch):
         monkeypatch.setattr(service, "IS_WINDOWS", True)
+        monkeypatch.setattr(service, "_auto_exe", lambda: "/py/Scripts/agentos-auto.exe")
         monkeypatch.setattr(service, "_run", lambda argv: (1, "Access is denied."))
         ok, msg = service._install_update_timer()
         assert ok is False and "Access is denied." in msg

devops_bot_sdk-1.6.68/tests/test_windows_task_paths.py

@@ -0,0 +1,172 @@
+"""Windows scheduled tasks must name their program by ABSOLUTE path.
+
+The incident: a Windows VPS on a regular (non-venv) Python install —
+``...\\pythoncore-3.14-64\\python.exe`` with its console scripts in the ``Scripts\\``
+subfolder. ``_exe()`` looked only next to ``python.exe`` and on PATH, found
+neither, and fell back to the bare ``agentos-ui.exe``. ``schtasks /Create``
+accepted that; Task Scheduler does not search PATH, so the panel task sat
+"Ready" with Last Result 0x80070002 (file not found) and never ran — no panel, no
+activity collector, no shipper, so that VPS never sent one activity event. And the
+ordinary update path only re-ran the broken task, so no update ever fixed it.
+"""
+from __future__ import annotations
+
+import sysconfig
+from pathlib import Path
+
+import pytest
+
+from sdk.ui import service
+
+
+@pytest.fixture
+def windows_install(monkeypatch, tmp_path):
+    """A regular Windows install: python.exe in the root, scripts in Scripts\\."""
+    root = tmp_path / "pythoncore-3.14-64"
+    scripts = root / "Scripts"
+    scripts.mkdir(parents=True)
+    monkeypatch.setattr(service, "IS_WINDOWS", True)
+    monkeypatch.setattr(service.sys, "executable", str(root / "python.exe"))
+    monkeypatch.setattr(service.shutil, "which", lambda name: None)   # Scripts\ not on PATH
+
+    def fake_get_path(name, scheme=None):
+        if scheme is None:
+            return str(scripts)
+        raise KeyError(scheme)
+    monkeypatch.setattr(sysconfig, "get_path", fake_get_path)
+    return scripts
+
+
+class TestResolution:
+    def test_finds_the_panel_in_the_scripts_subfolder(self, windows_install):
+        (windows_install / "agentos-ui.exe").write_text("")
+        assert service._exe() == str(windows_install / "agentos-ui.exe")
+
+    def test_finds_the_updater_in_the_scripts_subfolder(self, windows_install):
+        (windows_install / "agentos-auto.exe").write_text("")
+        assert service._auto_exe() == str(windows_install / "agentos-auto.exe")
+
+    def test_next_to_the_interpreter_still_wins(self, windows_install):
+        """A venv keeps python.exe and the scripts together; that copy is THIS SDK's."""
+        beside = Path(service.sys.executable).parent / "agentos-ui.exe"
+        beside.write_text("")
+        (windows_install / "agentos-ui.exe").write_text("")
+        assert service._exe() == str(beside)
+
+    def test_a_user_scheme_install_is_found(self, monkeypatch, windows_install, tmp_path):
+        user_scripts = tmp_path / "Roaming" / "Python" / "Python314" / "Scripts"
+        user_scripts.mkdir(parents=True)
+        (user_scripts / "agentos-ui.exe").write_text("")
+
+        def fake_get_path(name, scheme=None):
+            return str(user_scripts) if (scheme or "").endswith("_user") else str(windows_install)
+        monkeypatch.setattr(sysconfig, "get_path", fake_get_path)
+        assert service._exe() == str(user_scripts / "agentos-ui.exe")
+
+    def test_not_found_anywhere_is_the_bare_name(self, windows_install):
+        assert service._exe() == "agentos-ui.exe"
+
+
+class TestRefusesABareProgramName:
+    def test_panel_task_is_not_created(self, monkeypatch, windows_install):
+        calls = []
+        monkeypatch.setattr(service, "_run", lambda argv: (calls.append(argv), (0, ""))[1])
+        ok, msg = service._install_schtask("0.0.0.0", 8765)
+        assert ok is False
+        assert service.WIN_TASK in msg and "agentos-ui.exe" in msg
+        assert calls == []                      # never reached schtasks /Create
+
+    def test_update_task_is_not_created(self, monkeypatch, windows_install):
+        calls = []
+        monkeypatch.setattr(service, "_run", lambda argv: (calls.append(argv), (0, ""))[1])
+        ok, msg = service._install_update_schtask()
+        assert ok is False and service.WIN_UPDATE_TASK in msg
+        assert calls == []
+
+    def test_panel_task_uses_the_absolute_path_when_found(self, monkeypatch, windows_install):
+        exe = windows_install / "agentos-ui.exe"
+        exe.write_text("")
+        calls = []
+        monkeypatch.setattr(service, "_run", lambda argv: (calls.append(argv), (0, ""))[1])
+        ok, _ = service._install_schtask("0.0.0.0", 8765)
+        assert ok is True
+        create = calls[0]
+        assert create[:4] == ["schtasks", "/Create", "/TN", service.WIN_TASK]
+        assert create[create.index("/TR") + 1].startswith(f'"{exe}" --host 0.0.0.0')
+
+
+def _task_xml(command: str) -> str:
+    return ("<?xml version=\"1.0\" encoding=\"UTF-16\"?>\n<Task><Actions Context=\"Author\">"
+            f"<Exec><Command>{command}</Command><Arguments>--host 0.0.0.0</Arguments>"
+            "</Exec></Actions></Task>")
+
+
+class TestDetectsABrokenTask:
+    def test_a_bare_program_name_points_nowhere(self, monkeypatch):
+        monkeypatch.setattr(service, "_run", lambda argv: (0, _task_xml('"agentos-ui.exe"')))
+        assert service._schtask_points_nowhere(service.WIN_TASK) is True
+
+    def test_an_absolute_path_that_no_longer_exists_points_nowhere(self, monkeypatch, tmp_path):
+        gone = tmp_path / "old-venv" / "Scripts" / "agentos-ui.exe"
+        monkeypatch.setattr(service, "_run", lambda argv: (0, _task_xml(str(gone))))
+        assert service._schtask_points_nowhere(service.WIN_TASK) is True
+
+    def test_an_existing_absolute_path_is_fine(self, monkeypatch, tmp_path):
+        exe = tmp_path / "R&D" / "agentos-ui.exe"
+        exe.parent.mkdir()
+        exe.write_text("")
+        escaped = str(exe).replace("&", "&amp;")
+        monkeypatch.setattr(service, "_run", lambda argv: (0, _task_xml(f'"{escaped}"')))
+        assert service._schtask_points_nowhere(service.WIN_TASK) is False
+
+    def test_a_task_that_cannot_be_read_is_not_called_broken(self, monkeypatch):
+        """No task, or no permission to read it: not ours to rebuild on a guess."""
+        monkeypatch.setattr(service, "_run", lambda argv: (1, "ERROR: cannot find the file"))
+        assert service._schtask_points_nowhere(service.WIN_TASK) is False
+
+
+class TestEnsureRepairsIt:
+    @pytest.fixture
+    def installed(self, monkeypatch):
+        monkeypatch.setattr(service, "IS_WINDOWS", True)
+        monkeypatch.setattr(service, "_service_disabled", lambda: False)
+        monkeypatch.setattr(service, "is_installed", lambda: True)
+        monkeypatch.setattr(service, "update_timer_installed", lambda: True)
+        monkeypatch.setattr(service, "_needs_root_for_existing", lambda: False)
+        monkeypatch.setattr(service, "_with_token_warning", lambda m: m)
+        seen = {"refresh": 0, "timer": 0, "restart": 0}
+
+        def refresh():
+            seen["refresh"] += 1
+            return True, "service refreshed"
+
+        def timer():
+            seen["timer"] += 1
+            return True, "timer ok"
+
+        def restart():
+            seen["restart"] += 1
+            return True, "restarted"
+        monkeypatch.setattr(service, "refresh", refresh)
+        monkeypatch.setattr(service, "_install_update_timer", timer)
+        monkeypatch.setattr(service, "restart", restart)
+        monkeypatch.setattr(service, "_is_active", lambda: False)
+        return seen
+
+    def test_a_broken_panel_task_is_rebuilt_without_an_upgrade(self, monkeypatch, installed):
+        monkeypatch.setattr(service, "_schtask_points_nowhere", lambda task: task == service.WIN_TASK)
+        ok, msg = service.ensure(restart_running=False)
+        assert ok is True and "rebuilt" in msg
+        assert installed["refresh"] == 1 and installed["restart"] == 0
+
+    def test_a_broken_update_task_is_recreated(self, monkeypatch, installed):
+        monkeypatch.setattr(service, "_schtask_points_nowhere",
+                            lambda task: task == service.WIN_UPDATE_TASK)
+        service.ensure(restart_running=False)
+        assert installed["timer"] == 1
+
+    def test_a_healthy_stopped_task_is_just_started(self, monkeypatch, installed):
+        monkeypatch.setattr(service, "_schtask_points_nowhere", lambda task: False)
+        service.ensure(restart_running=False)
+        assert installed["refresh"] == 0 and installed["timer"] == 0
+        assert installed["restart"] == 1