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

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

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

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

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

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

@@ -34,7 +34,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.6.52"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.54"   # 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.52 → devops_bot_sdk-1.6.54}/sdk/activity/collectors/macos_eslogger.py

@@ -167,6 +167,17 @@ class EsloggerParser:
     def flush(self) -> None:
         """Nothing is buffered — every eslogger line is a whole event."""
 
+    def flush_older_than(self, cutoff: float) -> None:
+        """No-op, for the same reason as :meth:`flush`: nothing is held.
+
+        :class:`EsloggerCollector` reuses :class:`AuditdCollector`'s tail loop, which
+        calls this on the parser every poll to close auditd events whose trailing
+        records never arrived. An eslogger line is already a whole event, so there is
+        nothing to time-flush — but the method MUST exist, or the shared loop raises
+        ``AttributeError`` on its first idle poll and the whole collector thread dies
+        before a single event is recorded (the tail starts at EOF, so the very first
+        poll reads nothing and goes straight here)."""
+
     # ── sessions ─────────────────────────────────────────────────────────────
 
     def _asid_session(self, asid: int, ts: float) -> str:

{devops_bot_sdk-1.6.52 → devops_bot_sdk-1.6.54}/sdk/agentd.py

@@ -199,6 +199,11 @@ def _daemon_running() -> int | None:
     return None
 
 
+#: Set in the environment right before the macOS re-exec below, read back by the
+#: fresh interpreter so it knows it IS the detached daemon and must not fork again.
+_DAEMONIZED_ENV = "AGENTOS_AGENTD_DAEMONIZED"
+
+
 def _daemonize() -> bool:
     """Detach the current process from the terminal (POSIX double-fork).
 
@@ -207,10 +212,23 @@ def _daemonize() -> bool:
     _LOG_FILE and a PID file is written so `status` can find the daemon.
     Returns False (stays in the foreground) on platforms without os.fork
     (e.g. Windows).
+
+    On macOS the detached child re-execs a fresh interpreter instead of running
+    the daemon in-process (see below); ``main()`` re-enters here with the
+    ``_DAEMONIZED_ENV`` marker set, where setsid, the redirected fds 0/1/2 and the
+    PID file already survive the exec, so we only re-point the stream wrappers.
     """
     if not hasattr(os, "fork"):
         return False  # caller falls back to foreground
 
+    if os.environ.get(_DAEMONIZED_ENV) == "1":
+        # Don't leak the one-shot marker to subprocesses the daemon later spawns
+        # (claude, git, …) — they must never think THEY are the detached daemon.
+        os.environ.pop(_DAEMONIZED_ENV, None)
+        sys.stdout = open(_LOG_FILE, "a", buffering=1, encoding="utf-8")
+        sys.stderr = sys.stdout
+        return True
+
     _AGENTOS_DIR.mkdir(parents=True, exist_ok=True)
 
     # First fork: let the shell reap the parent and return the prompt.
@@ -232,13 +250,27 @@ def _daemonize() -> bool:
     os.close(devnull)
     os.close(logfd)
 
+    _PID_FILE.write_text(str(os.getpid()))
+
+    # macOS: re-exec a FRESH interpreter so the daemon's networking runs in a clean
+    # process image. A bare double-fork() with NO exec() leaves Apple's higher-level
+    # frameworks (Network.framework DNS/NAT64, the libsystem_trace os_log cache)
+    # half-initialised in the child, and the first getaddrinfo on the asyncio resolver
+    # thread then SIGSEGVs ("crashed on child side of fork pre-exec"). OBJC_DISABLE_
+    # INITIALIZE_FORK_SAFETY silences only the objc guard, not these — so it is not
+    # enough on macOS 26. The exec'd process keeps this PID, setsid session and fds.
+    if sys.platform == "darwin":
+        os.environ[_DAEMONIZED_ENV] = "1"
+        try:
+            os.execv(sys.executable, [sys.executable, sys.argv[0], *sys.argv[1:]])
+        except Exception:  # noqa: BLE001 — exec failed; fall back to in-process daemon
+            os.environ.pop(_DAEMONIZED_ENV, None)
+
     # Line-buffer stdout/stderr so progress reaches the log live rather than
     # sitting in Python's block-buffer for a non-tty stream (same fix
     # sdk/run_auto.py applies for the same reason).
     sys.stdout = open(_LOG_FILE, "a", buffering=1, encoding="utf-8")
     sys.stderr = sys.stdout
-
-    _PID_FILE.write_text(str(os.getpid()))
     return True
 
 
@@ -736,17 +768,22 @@ class AgentDaemon:
 
 def start(foreground: bool = False) -> None:
     """Start agentd — in the background by default, attached with --foreground."""
+    # macOS re-exec of the already-detached daemon (see _daemonize): this process
+    # IS the daemon — the duplicate guard, banner and stop-flag clear all ran in
+    # the original process before the fork, so skip straight to re-detaching.
+    resuming = os.environ.get(_DAEMONIZED_ENV) == "1"
     if not foreground:
-        pid = _daemon_running()
-        if pid:
-            print(f"agentd is already running in the background (pid {pid}).")
-            print(f"  logs:   {_LOG_FILE}")
-            return
+        if not resuming:
+            pid = _daemon_running()
+            if pid:
+                print(f"agentd is already running in the background (pid {pid}).")
+                print(f"  logs:   {_LOG_FILE}")
+                return
 
-        print("agentd starting in the background — it keeps running after you "
-              "close this terminal.")
-        print(f"  logs:   {_LOG_FILE}")
-        _clear_stop()  # a fresh start clears any stale stop flag
+            print("agentd starting in the background — it keeps running after you "
+                  "close this terminal.")
+            print(f"  logs:   {_LOG_FILE}")
+            _clear_stop()  # a fresh start clears any stale stop flag
         if not _daemonize():
             print("note: background mode unavailable on this platform — running "
                   "in the foreground.")

{devops_bot_sdk-1.6.52 → devops_bot_sdk-1.6.54}/sdk/platform_compat.py

@@ -80,12 +80,21 @@ def ensure_utf8_stdio() -> None:
 def ensure_macos_fork_safety() -> None:
     """Stop macOS from killing our background daemons with a native abort.
 
-    ``agentos-auto`` / ``agentos-agentd`` double-fork (fork + setsid, no exec)
-    into a background daemon that then does networking (httpx → CFNetwork /
+    ``agentos-auto`` / ``agentos-agentd`` double-fork (fork + setsid) into a
+    background daemon that then does networking (httpx → CFNetwork /
     SystemConfiguration) and TLS. When the Objective-C runtime detects objc use
     after a bare ``fork()`` with no ``exec()`` it calls ``abort()`` — which macOS
     surfaces as the "Python quit unexpectedly" crash dialog. Exporting
-    ``OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES`` disables that guard.
+    ``OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES`` disables that *objc* guard.
+
+    It is NOT sufficient on its own: Apple's higher-level frameworks (Network.
+    framework's DNS/NAT64 path, the libsystem_trace ``os_log`` cache) are also
+    fork-unsafe and will SIGSEGV in the forked child on the first ``getaddrinfo``
+    — the env var does not cover them. The actual fix for that is in each daemon's
+    ``_daemonize()``, which re-execs a fresh interpreter after the double-fork so
+    the daemon runs in a clean process image. This shim remains the belt to that
+    braces: it quiets the objc guard and short-circuits the ``_scproxy`` lookup for
+    any pre-fork or non-daemon objc use, and seeds the var for the exec'd child.
 
     The objc runtime reads that variable when its dylib is first mapped (that is
     interpreter startup on framework Python builds), so setting it via

{devops_bot_sdk-1.6.52 → devops_bot_sdk-1.6.54}/sdk/run_auto.py

@@ -330,6 +330,23 @@ def _daemon_running() -> int | None:
     return None
 
 
+#: Set in the environment right before the macOS re-exec below, read back by the
+#: fresh interpreter so it knows it IS the detached daemon and must not fork again.
+_DAEMONIZED_ENV = "AGENTOS_AUTO_DAEMONIZED"
+
+
+def _relog_line_buffered() -> None:
+    """Point sys.stdout/stderr at _LOG_FILE line-buffered.
+
+    When stdout is a file (not a tty) Python block-buffers it, so progress printed
+    via _send() would sit in the buffer and never reach the log until the process
+    exits — making the daemon look idle. A line-buffered writer flushes every
+    progress line live, exactly like the foreground run.
+    """
+    sys.stdout = open(_LOG_FILE, "a", buffering=1, encoding="utf-8")
+    sys.stderr = sys.stdout
+
+
 def _daemonize() -> bool:
     """Detach the current process from the terminal (POSIX double-fork).
 
@@ -337,10 +354,23 @@ def _daemonize() -> bool:
     os._exit() and never return. stdout/stderr are redirected to _LOG_FILE and a
     PID file is written so `stop`/`status` can find the loop. Returns False (stays
     in the foreground) on platforms without os.fork (e.g. Windows).
+
+    On macOS the detached child does NOT run the loop in-process: it re-execs a
+    fresh interpreter (see below) and ``main()`` re-enters here with the
+    ``_DAEMONIZED_ENV`` marker set — at which point setsid, the redirected fds
+    0/1/2 and the PID file already survive from before the exec, so we only
+    re-point the Python stream wrappers and report "I am the daemon".
     """
     if not hasattr(os, "fork"):
         return False  # caller falls back to foreground
 
+    if os.environ.get(_DAEMONIZED_ENV) == "1":
+        # Don't leak the one-shot marker to subprocesses the loop later spawns
+        # (claude, git, …) — they must never think THEY are the detached daemon.
+        os.environ.pop(_DAEMONIZED_ENV, None)
+        _relog_line_buffered()
+        return True
+
     _AGENTOS_DIR.mkdir(parents=True, exist_ok=True)
 
     # First fork: let the shell reap the parent and return the prompt.
@@ -362,15 +392,24 @@ def _daemonize() -> bool:
     os.close(devnull)
     os.close(logfd)
 
-    # CRITICAL: when stdout is a file (not a tty) Python block-buffers it, so
-    # progress printed via _send() would sit in the buffer and never reach the
-    # log until the process exits — making the daemon look idle. Replace the
-    # streams with line-buffered writers so every progress line is flushed live,
-    # exactly like the foreground run.
-    sys.stdout = open(_LOG_FILE, "a", buffering=1, encoding="utf-8")
-    sys.stderr = sys.stdout
-
     _write_pid()
+
+    # macOS: re-exec a FRESH interpreter so the daemon that does networking runs in
+    # a clean process image. A bare double-fork() with NO exec() leaves Apple's
+    # higher-level frameworks (Network.framework's DNS/NAT64 path, the libsystem_trace
+    # os_log cache) half-initialised in the child, and the FIRST getaddrinfo on the
+    # asyncio resolver thread then SIGSEGVs ("crashed on child side of fork pre-exec").
+    # OBJC_DISABLE_INITIALIZE_FORK_SAFETY only silences the objc +initialize guard,
+    # NOT these frameworks — so the env var alone is not enough on macOS 26. The exec'd
+    # process keeps this PID, this setsid session and the fds 0/1/2 redirected above.
+    if sys.platform == "darwin":
+        os.environ[_DAEMONIZED_ENV] = "1"
+        try:
+            os.execv(sys.executable, [sys.executable, sys.argv[0], *sys.argv[1:]])
+        except Exception:  # noqa: BLE001 — exec failed; fall back to in-process daemon
+            os.environ.pop(_DAEMONIZED_ENV, None)
+
+    _relog_line_buffered()
     return True
 
 
@@ -1460,6 +1499,11 @@ def main() -> None:
         #   ticket K...  → ONLY the named Jira keys (any status, in order)
         #   story [K...] → convert Stories → Tasks only (with PRD); NO coding.
         #                  With keys: those Stories; without: every To Do Story.
+        # macOS re-exec of the already-detached daemon (see _daemonize): this
+        # process IS the loop owner — the update, the duplicate-loop guard and the
+        # banner all ran in the original process before the fork, so skip them and
+        # go straight to detaching (a no-op fork here) and running the loop.
+        resuming = os.environ.get(_DAEMONIZED_ENV) == "1"
         only_keys: list[str] | None = None
         stories_only = cmd in ("story", "stories")
         # `--agent-only` narrows whichever mode was chosen to the agent-tagged
@@ -1480,17 +1524,19 @@ def main() -> None:
         # long-lived old daemon would pin `stop`/`status` to a stale version. Runs
         # in the FOREGROUND so the user sees update output; re-execs on the new
         # code. Skipped with --no-update or AGENTOS_NO_UPDATE=1.
-        if "--no-update" not in argv:
+        if not resuming and "--no-update" not in argv:
             from sdk.updater import auto_update_and_reexec
             auto_update_and_reexec("sdk.run_auto", sys.argv[1:])
 
         # Refuse to start a second loop — one background daemon owns the queue.
-        pid = _daemon_running()
-        if pid:
-            print(f"agentos-auto is already running in the background (pid {pid}).")
-            print(f"  logs:   {_LOG_FILE}")
-            print("  stop:   agentos-auto stop")
-            return
+        # (The re-exec'd daemon IS that loop; its own live PID would trip this.)
+        if not resuming:
+            pid = _daemon_running()
+            if pid:
+                print(f"agentos-auto is already running in the background (pid {pid}).")
+                print(f"  logs:   {_LOG_FILE}")
+                print("  stop:   agentos-auto stop")
+                return
 
         workspace_root = _parse_workspace_root(argv)
 
@@ -1513,7 +1559,7 @@ def main() -> None:
         # the loop — it runs until `agentos-auto stop`. `--foreground`/`-f` keeps it
         # attached (useful for debugging). On platforms without fork we stay attached.
         foreground = "--foreground" in argv or "-f" in argv
-        if not foreground and hasattr(os, "fork"):
+        if not foreground and not resuming and hasattr(os, "fork"):
             if stories_only:
                 target = (f" — stories→tasks: {', '.join(only_keys)}" if only_keys
                           else " — converting all To Do Stories → Tasks")
@@ -1527,7 +1573,7 @@ def main() -> None:
             print("  status: agentos-auto status")
             print("  stop:   agentos-auto stop")
         if not foreground and _daemonize():
-            # detached daemon child only
+            # detached daemon child only (on macOS, the re-exec'd process)
             _run_loop(workspace_root, only_keys, stories_only, agent_only)
             return
         if not foreground:

{devops_bot_sdk-1.6.52 → devops_bot_sdk-1.6.54}/tests/test_activity_macos.py

@@ -158,6 +158,37 @@ class TestParser:
         c = M.EsloggerCollector(str(log), parser=_parser(), state_file=tmp_path / "st.json")
         assert c._state == tmp_path / "st.json"
 
+    def test_tail_loop_records_events_and_does_not_crash_on_an_idle_poll(
+        self, tmp_path, monkeypatch
+    ):
+        """Regression: EsloggerCollector reuses AuditdCollector's tail loop, which calls
+        ``parser.flush_older_than`` on EVERY poll. EsloggerParser was missing it, so the
+        collector thread died with AttributeError on its first (idle) poll — the tail
+        starts at EOF, so the first poll reads nothing and goes straight to that call —
+        and not a single event was ever recorded (SDK v1.6.52 on the Mac VPS)."""
+        from sdk.activity.collectors import linux_auditd as L
+
+        log = tmp_path / "es.ndjson"
+        log.write_text(_exec(1, ["old"], tty="/dev/ttys001") + "\n")  # pre-install: not backfilled
+        collector = M.EsloggerCollector(
+            str(log), parser=_parser(), state_file=tmp_path / "st.json", poll_s=0,
+        )
+        calls = {"n": 0}
+
+        def fake_sleep(_):
+            calls["n"] += 1
+            if calls["n"] == 1:   # new activity lands after the first, empty poll
+                with log.open("a") as fh:
+                    fh.write(_exec(2, ["whoami"], tty="/dev/ttys001") + "\n")
+            else:
+                collector.stop()
+
+        monkeypatch.setattr(L.time, "sleep", fake_sleep)
+        collector.run()   # before the fix: raises AttributeError out of the loop
+
+        _, events = _queued()
+        assert [e["command"] for e in events] == ["whoami"]
+
 
 # ─────────────────────────────── setup ───────────────────────────────
 

{devops_bot_sdk-1.6.52 → devops_bot_sdk-1.6.54}/tests/test_run_auto_agent_only.py

@@ -27,6 +27,7 @@ from __future__ import annotations
 
 import asyncio
 import os
+import sys
 
 import pytest
 
@@ -596,6 +597,91 @@ def test_the_running_daemon_guard_still_wins(monkeypatch, tmp_path, capsys):
     assert "already running in the background (pid 4242)" in capsys.readouterr().out
 
 
+# ── macOS fork-safety: the daemon re-execs a fresh interpreter ──────────────
+# A bare double-fork() with no exec() leaves Apple's Network.framework / os_log
+# half-initialised in the child, so the first getaddrinfo on the asyncio resolver
+# thread SIGSEGVs ("crashed on child side of fork pre-exec"). _daemonize() re-execs
+# the interpreter after detaching; main() re-enters with _DAEMONIZED_ENV set and
+# must treat THIS process as the loop owner — not fork again, not trip its own guard.
+
+def test_the_reexec_daemon_is_the_loop_not_a_second_one(monkeypatch, tmp_path, capsys):
+    """The re-exec'd daemon keeps the PID written before the exec, so _daemon_running()
+    would report IT as 'already running' and the loop would exit on its own guard.
+    With the marker set that guard — and the update and the banner — must be skipped."""
+    calls = _stub_main(monkeypatch, tmp_path, resolved=None, forkable=True)
+    monkeypatch.setattr(run_auto, "_daemon_running", lambda: os.getpid())  # our own live PID
+    monkeypatch.setenv(run_auto._DAEMONIZED_ENV, "1")
+    monkeypatch.setattr("sys.argv", ["agentos-auto"])  # no --no-update either
+
+    run_auto.main()
+
+    assert calls["run_loop"] == [(None, None, False, False)]   # the loop actually ran
+    out = capsys.readouterr().out
+    assert "already running" not in out and "started in the background" not in out
+
+
+def test_daemonize_marker_short_circuits_without_forking(monkeypatch, tmp_path):
+    """Re-entered with the marker, _daemonize() must report 'I am the daemon' WITHOUT
+    forking (setsid/fds/PID already survive the exec) and clear the marker so the
+    children the loop later spawns don't inherit it and skip their own daemonizing."""
+    monkeypatch.setattr(run_auto, "_LOG_FILE", tmp_path / "auto.log")
+    monkeypatch.setenv(run_auto._DAEMONIZED_ENV, "1")
+    monkeypatch.setattr(os, "fork", lambda: (_ for _ in ()).throw(AssertionError("forked")))
+
+    saved_out, saved_err = sys.stdout, sys.stderr
+    try:
+        assert run_auto._daemonize() is True
+    finally:
+        sys.stdout.close()
+        sys.stdout, sys.stderr = saved_out, saved_err
+
+    assert run_auto._DAEMONIZED_ENV not in os.environ   # not leaked to spawned children
+
+
+class _ExecvReached(BaseException):
+    """Marks that os.execv was called — a BaseException so _daemonize's
+    ``except Exception`` fallback does not swallow it."""
+
+
+def test_macos_daemonize_reexecs_a_fresh_interpreter(monkeypatch, tmp_path):
+    """On macOS the detached child does not run in-process: it re-execs the
+    interpreter (clean Network.framework state) with the marker set, carrying the
+    same argv so main() resumes the loop."""
+    monkeypatch.setattr(sys, "platform", "darwin")
+    monkeypatch.setattr(run_auto, "_LOG_FILE", tmp_path / "auto.log")
+    monkeypatch.setattr(run_auto, "_AGENTOS_DIR", tmp_path)
+    monkeypatch.setattr(run_auto, "_write_pid", lambda: None)
+    monkeypatch.delenv(run_auto._DAEMONIZED_ENV, raising=False)
+    monkeypatch.setattr(os, "fork", lambda: 0)          # always the child
+    monkeypatch.setattr(os, "setsid", lambda: None)
+    monkeypatch.setattr(os, "open", lambda *a, **k: 3)
+    monkeypatch.setattr(os, "dup2", lambda *a: None)
+    monkeypatch.setattr(os, "close", lambda *a: None)
+    # Under pytest the captured std streams have no real fileno(); the fd shuffle
+    # is already a no-op above, so hand _daemonize plain stand-ins to flush/number.
+    fake_std = type("S", (), {"flush": lambda self: None, "fileno": lambda self: 0})()
+    monkeypatch.setattr(sys, "stdin", fake_std)
+    monkeypatch.setattr(sys, "stdout", fake_std)
+    monkeypatch.setattr(sys, "stderr", fake_std)
+    monkeypatch.setattr("sys.argv", ["agentos-auto", "ticket", "BBW-9"])
+
+    seen = {}
+
+    def fake_execv(exe, argv):
+        seen["exe"], seen["argv"] = exe, argv
+        seen["marker"] = os.environ.get(run_auto._DAEMONIZED_ENV)
+        raise _ExecvReached
+
+    monkeypatch.setattr(os, "execv", fake_execv)
+
+    with pytest.raises(_ExecvReached):
+        run_auto._daemonize()
+
+    assert seen["exe"] == sys.executable
+    assert seen["argv"] == [sys.executable, "agentos-auto", "ticket", "BBW-9"]
+    assert seen["marker"] == "1"   # the fresh interpreter learns it is the daemon
+
+
 def test_the_docstring_documents_the_flag_and_the_suffix():
     doc = run_auto.__doc__ or ""
     assert "--agent-only" in doc                     # Options block