devops-bot-sdk 1.6.42__tar.gz → 1.6.46__tar.gz

{devops_bot_sdk-1.6.42 → devops_bot_sdk-1.6.46}/PKG-INFO

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

{devops_bot_sdk-1.6.42 → devops_bot_sdk-1.6.46}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.42 → devops_bot_sdk-1.6.46}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -54,6 +54,7 @@ sdk/write_hook.py
 sdk/activity/__init__.py
 sdk/activity/classifier.py
 sdk/activity/models.py
+sdk/activity/os_setup.py
 sdk/activity/recorder.py
 sdk/activity/redact.py
 sdk/activity/settings.py
@@ -62,6 +63,7 @@ sdk/activity/spool.py
 sdk/activity/collectors/__init__.py
 sdk/activity/collectors/common.py
 sdk/activity/collectors/linux_auditd.py
+sdk/activity/collectors/macos_eslogger.py
 sdk/activity/collectors/windows_eventlog.py
 sdk/agents/__init__.py
 sdk/agents/activity.py
@@ -137,6 +139,8 @@ sdk/ui/static/styles.css
 sdk/ui/static/tickets.html
 tests/test_activity_collectors.py
 tests/test_activity_core.py
+tests/test_activity_macos.py
+tests/test_activity_os_setup.py
 tests/test_activity_pipeline.py
 tests/test_agent_activity.py
 tests/test_agent_activity_tracking.py

{devops_bot_sdk-1.6.42 → devops_bot_sdk-1.6.46}/sdk/__init__.py

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

@@ -2,10 +2,8 @@
 
     Linux    auditd         sdk.activity.collectors.linux_auditd
     Windows  Security log   sdk.activity.collectors.windows_eventlog
-    macOS    not supported yet — a faithful collector needs an Endpoint Security
-             client, which is a signed system extension rather than Python. See
-             docs/ACTIVITY_AUDIT.md. (Agent runs are still recorded on macOS: that
-             part is the SDK's own and needs no OS support.)
+    macOS    Endpoint Security, through Apple's own ``eslogger`` (macOS 13+)
+                            sdk.activity.collectors.macos_eslogger
 
 ``start()`` has the same contract as the other crons the UI lifespan starts
 (``sdk.vps_health.start`` …): it returns an asyncio task, or ``None`` when disabled
@@ -47,6 +45,17 @@ def make_collector(os_name: Os | None = None) -> Any | None:
         )
 
         return WindowsEventLogCollector(WindowsEventProcessor(agent_user=AGENT_OS_USER))
+    if os_name is Os.MACOS:
+        from sdk.activity.collectors.macos_eslogger import EsloggerCollector, EsloggerParser
+
+        mac_uid: int | None = None
+        try:
+            import pwd
+
+            mac_uid = pwd.getpwnam(AGENT_OS_USER).pw_uid
+        except Exception:  # noqa: BLE001 — no such user (yet)
+            mac_uid = None
+        return EsloggerCollector(parser=EsloggerParser(agent_uid=mac_uid))
     return None
 
 

devops_bot_sdk-1.6.46/sdk/activity/collectors/macos_eslogger.py

@@ -0,0 +1,356 @@
+"""macOS collector: turns Endpoint Security events (via Apple's ``eslogger``) into
+sessions and events.
+
+A faithful macOS collector needs an Endpoint Security client, and an ES client must
+be a signed, entitled binary — which this Python SDK cannot be. Apple ships one:
+``/usr/bin/eslogger`` (macOS 13+) subscribes to ES events and prints each as a line
+of JSON. So macOS gets the same shape as Linux:
+
+    eslogger (root LaunchDaemon, set up by sdk.activity.os_setup)
+        → /var/log/agentos/eslogger.ndjson        (like auditd → audit.log)
+        → EsloggerCollector tails it in the panel  (like AuditdCollector)
+
+Events used:
+
+* ``exec``                                  → a COMMAND event, one per exec
+* ``openssh_login`` / ``openssh_logout``    → SSH LOGIN / LOGOUT and the login session
+* ``login_login`` / ``login_logout``,
+  ``lw_session_login`` / ``lw_session_logout`` → CONSOLE LOGIN / LOGOUT
+* ``sudo`` / ``su``                         → a PRIVILEGE event
+
+eslogger's JSON mirrors ``es_message_t``: ``event_type``, ``time``, ``process`` (with
+``audit_token`` → pid/euid/ruid/auid/asid, ``ppid``, ``executable.path``, ``tty``) and
+``event`` holding exactly one key named after the event. Field access here is
+defensive (``.get`` everywhere): the format is Apple's and has grown between macOS
+releases.
+
+The parser is pure and stateful — feed it lines, it records through
+:mod:`sdk.activity.recorder` — so it is testable without a Mac. Attribution follows
+the Linux collector: agentos provenance (registry, or ``AGENTOS_RUN_ID`` in the exec
+environment when eslogger includes it) → the ``agentos`` OS user → an interactive
+session (a tty, or an audit session opened by a login) → launchd with no terminal =
+SYSTEM. SYSTEM execs are skipped by default, as on Windows: a Mac runs a constant
+stream of ``xpcproxy`` / ``mdworker`` housekeeping that is nobody's action.
+"""
+from __future__ import annotations
+
+import json
+import logging
+from collections import OrderedDict
+from collections.abc import Callable
+from datetime import datetime
+from pathlib import Path
+
+from sdk.activity import recorder
+from sdk.activity.classifier import AgentProcessRegistry, ProcessFacts, classify
+from sdk.activity.collectors.common import SessionBook
+from sdk.activity.collectors.linux_auditd import AuditdCollector
+from sdk.activity.models import (
+    ActivityEvent,
+    ActorType,
+    Category,
+    Os,
+    SessionKind,
+    Severity,
+    Source,
+)
+
+logger = logging.getLogger("sdk.activity.collectors.macos")
+
+DEFAULT_ES_LOG = "/var/log/agentos/eslogger.ndjson"
+
+#: The ES events the LaunchDaemon subscribes to — kept here so os_setup and the
+#: parser cannot disagree about them.
+ES_EVENTS = (
+    "exec",
+    "openssh_login", "openssh_logout",
+    "login_login", "login_logout",
+    "lw_session_login", "lw_session_logout",
+    "sudo", "su",
+)
+
+#: ``auid`` when no login owns the process (AU_DEFAUDITID).
+_UNSET_AUID = {4294967295, -1}
+_MAX_PID_CACHE = 20_000
+
+
+def _ts(msg: dict) -> float:
+    raw = msg.get("time")
+    if isinstance(raw, str):
+        try:
+            return datetime.fromisoformat(raw.replace("Z", "+00:00")).timestamp()
+        except ValueError:
+            pass
+    import time
+
+    return time.time()
+
+
+def _token(proc: dict | None) -> dict:
+    return (proc or {}).get("audit_token") or {}
+
+
+def _path(obj) -> str | None:
+    """``{"path": "/bin/ls", ...}`` → ``/bin/ls``; tolerates a bare string or null."""
+    if isinstance(obj, dict):
+        return obj.get("path") or None
+    return obj or None
+
+
+def _uid(obj) -> int | None:
+    """eslogger nests uids as ``{"uid": 501}``; accept a bare int too."""
+    if isinstance(obj, dict):
+        obj = obj.get("uid")
+    try:
+        return int(obj) if obj is not None else None
+    except (TypeError, ValueError):
+        return None
+
+
+def _default_user_name(uid: int | None) -> str | None:
+    if uid is None or uid in _UNSET_AUID:
+        return None
+    try:
+        import pwd
+
+        return pwd.getpwuid(uid).pw_name
+    except Exception:  # noqa: BLE001 — unknown uid, not POSIX
+        return str(uid)
+
+
+def _env_run_id(env) -> str | None:
+    """``AGENTOS_RUN_ID`` from an exec's environment, when eslogger included it."""
+    for item in env or []:
+        if isinstance(item, str) and item.startswith("AGENTOS_RUN_ID="):
+            return item.split("=", 1)[1] or None
+    return None
+
+
+class EsloggerParser:
+    def __init__(
+        self,
+        *,
+        agent_uid: int | None = None,
+        registry: AgentProcessRegistry | None = None,
+        user_name: Callable[[int | None], str | None] = _default_user_name,
+        book: SessionBook | None = None,
+        ignore_system: bool = True,
+    ) -> None:
+        self._agent_uid = agent_uid
+        self._registry = registry or AgentProcessRegistry()
+        self._user_name = user_name
+        self._book = book or SessionBook()
+        self._ignore_system = ignore_system
+        self._ppid: OrderedDict[int, int] = OrderedDict()
+        self._asid_key: dict[int, str] = {}           # audit session id → our session key
+        self._asid_kind: dict[int, SessionKind] = {}
+        self._ssh: dict[tuple[str, str], str] = {}     # (user, source) → session key
+
+    # ── input ────────────────────────────────────────────────────────────────
+
+    def feed(self, line: str) -> None:
+        line = line.strip()
+        if not line.startswith("{"):
+            return
+        try:
+            msg = json.loads(line)
+            event = msg.get("event") or {}
+            if not isinstance(event, dict) or not event:
+                return
+            name, body = next(iter(event.items()))
+            handler = getattr(self, f"_on_{name}", None)
+            if handler is not None:
+                handler(msg, body or {})
+        except Exception as exc:  # noqa: BLE001 — one bad line must not stop the tail
+            logger.warning("eslogger: could not process line: %s", exc)
+
+    def flush(self) -> None:
+        """Nothing is buffered — every eslogger line is a whole event."""
+
+    # ── sessions ─────────────────────────────────────────────────────────────
+
+    def _asid_session(self, asid: int, ts: float) -> str:
+        key = self._asid_key.get(asid)
+        if key is None:
+            # asids are reused after a reboot; the first-seen time keeps keys unique.
+            key = f"es-asid:{asid}:{int(ts)}"
+            self._asid_key[asid] = key
+        return key
+
+    def _login(self, msg: dict, *, kind: SessionKind, user: str | None, uid: int | None,
+               remote: str | None, ok: bool, action: str = "login") -> str | None:
+        ts = _ts(msg)
+        if not ok:
+            recorder.record_event(ActivityEvent(
+                os=Os.MACOS, source=Source.ENDPOINT_SECURITY, category=Category.LOGIN,
+                action="login.failed", occurredAt=ts, osUser=user, target=remote,
+                severity=Severity.WARNING, actorType=ActorType.UNKNOWN, actorConfidence=0,
+            ))
+            return None
+        verdict = classify(ProcessFacts(
+            login_kind=kind, has_tty=True, is_agent_os_user=self._is_agent(uid),
+        ))
+        asid = _token(msg.get("process")).get("asid")
+        key = (self._asid_session(int(asid), ts) if isinstance(asid, int) and asid > 0
+               else f"es-login:{user}:{remote or 'local'}:{int(ts)}")
+        if isinstance(asid, int) and asid > 0:
+            self._asid_kind[int(asid)] = kind
+        info = self._book.ensure(key, started=ts, verdict=verdict, kind=kind,
+                                 os_user=user, remote_ip=remote)
+        recorder.record_event(ActivityEvent(
+            os=Os.MACOS, source=Source.ENDPOINT_SECURITY, category=Category.LOGIN,
+            action=action, occurredAt=ts, sessionKey=key, osUser=user, target=remote,
+            agentRunId=info.agent_run_id,
+        ))
+        return key
+
+    def _logout(self, msg: dict, key: str | None, user: str | None) -> None:
+        if not key:
+            return
+        ts = _ts(msg)
+        recorder.record_event(ActivityEvent(
+            os=Os.MACOS, source=Source.ENDPOINT_SECURITY, category=Category.LOGOUT,
+            action="logout", occurredAt=ts, sessionKey=key, osUser=user,
+        ))
+        self._book.end(key, ts)
+        for asid, k in list(self._asid_key.items()):
+            if k == key:
+                self._asid_key.pop(asid, None)
+                self._asid_kind.pop(asid, None)
+
+    # ── handlers (named _on_<eslogger event>) ───────────────────────────────
+
+    def _on_openssh_login(self, msg: dict, ev: dict) -> None:
+        user = ev.get("username") or None
+        remote = ev.get("source_address") or None
+        key = self._login(msg, kind=SessionKind.SSH, user=user, uid=_uid(ev.get("uid")),
+                          remote=remote, ok=bool(ev.get("success", True)))
+        if key:
+            self._ssh[(str(user), str(remote))] = key
+
+    def _on_openssh_logout(self, msg: dict, ev: dict) -> None:
+        user = ev.get("username") or None
+        key = self._ssh.pop((str(user), str(ev.get("source_address") or None)), None)
+        self._logout(msg, key, user)
+
+    def _on_login_login(self, msg: dict, ev: dict) -> None:
+        self._login(msg, kind=SessionKind.CONSOLE, user=ev.get("username") or None,
+                    uid=_uid(ev.get("uid")), remote=None, ok=bool(ev.get("success", True)))
+
+    def _on_lw_session_login(self, msg: dict, ev: dict) -> None:
+        self._login(msg, kind=SessionKind.CONSOLE, user=ev.get("username") or None,
+                    uid=None, remote=None, ok=True)
+
+    def _console_logout(self, msg: dict, ev: dict) -> None:
+        asid = _token(msg.get("process")).get("asid")
+        key = self._asid_key.get(int(asid)) if isinstance(asid, int) else None
+        self._logout(msg, key, ev.get("username") or None)
+
+    _on_login_logout = _console_logout
+    _on_lw_session_logout = _console_logout
+
+    def _privilege(self, msg: dict, ev: dict, action: str) -> None:
+        ts = _ts(msg)
+        tok = _token(msg.get("process"))
+        asid = tok.get("asid")
+        ok = bool(ev.get("success", True))
+        recorder.record_event(ActivityEvent(
+            os=Os.MACOS, source=Source.ENDPOINT_SECURITY, category=Category.PRIVILEGE,
+            action=action, occurredAt=ts,
+            sessionKey=self._asid_key.get(int(asid)) if isinstance(asid, int) else None,
+            osUser=ev.get("from_username") or self._user_name(_uid(ev.get("from_uid"))),
+            command=ev.get("command") or None,
+            target=ev.get("to_username") or None,
+            pid=tok.get("pid"),
+            severity=Severity.NOTICE if ok else Severity.WARNING,
+            exitCode=0 if ok else 1,
+        ))
+
+    def _on_sudo(self, msg: dict, ev: dict) -> None:
+        self._privilege(msg, ev, "sudo")
+
+    def _on_su(self, msg: dict, ev: dict) -> None:
+        self._privilege(msg, ev, "su")
+
+    def _on_exec(self, msg: dict, ev: dict) -> None:
+        ts = _ts(msg)
+        target = ev.get("target") or {}
+        tok = _token(target) or _token(msg.get("process"))
+        pid = int(tok.get("pid") or 0)
+        ppid = int(target.get("ppid") or (msg.get("process") or {}).get("ppid") or 0)
+        self._remember_ppid(pid, ppid)
+        euid, auid, asid = tok.get("euid"), tok.get("auid"), tok.get("asid")
+        login = isinstance(auid, int) and auid not in _UNSET_AUID
+        tty = _path(target.get("tty"))
+        has_tty = bool(tty)
+
+        root = self._registry.lookup(pid, self._ppid.get)
+        run_id = root.run_id if root else _env_run_id(ev.get("env"))
+        known_asid = isinstance(asid, int) and asid in self._asid_key
+
+        verdict = classify(ProcessFacts(
+            descends_from_agent=bool(run_id),
+            agent_run_id=run_id,
+            is_agent_os_user=self._is_agent(euid) or self._is_agent(auid),
+            has_tty=has_tty,
+            login_kind=self._asid_kind.get(asid) if isinstance(asid, int) else None,
+            spawned_by_service_manager=not login and not has_tty and not known_asid,
+        ))
+        if verdict.actor_type is ActorType.SYSTEM and self._ignore_system:
+            return
+
+        if run_id:
+            session_key, agent_run_id = recorder.agent_session_key(run_id), run_id
+        elif isinstance(asid, int) and asid > 0 and (login or has_tty or known_asid):
+            session_key = self._asid_session(asid, ts)
+            info = self._book.ensure(session_key, started=ts, verdict=verdict,
+                                     os_user=self._user_name(auid if login else euid))
+            agent_run_id = info.agent_run_id
+        elif verdict.actor_type is ActorType.AGENT:
+            session_key = f"os-user:{euid}:{int(ts) // 86400}"
+            info = self._book.ensure(session_key, started=ts, verdict=verdict,
+                                     os_user=self._user_name(euid))
+            agent_run_id = info.agent_run_id
+        else:
+            session_key, agent_run_id = None, None
+
+        args = ev.get("args")
+        command = " ".join(str(a) for a in args) if isinstance(args, list) else None
+        exe = _path(target.get("executable"))
+        recorder.record_event(ActivityEvent(
+            os=Os.MACOS, source=Source.ENDPOINT_SECURITY, category=Category.COMMAND,
+            action="exec", occurredAt=ts, sessionKey=session_key,
+            actorType=verdict.actor_type, actorConfidence=verdict.confidence,
+            agentRunId=agent_run_id,
+            osUser=self._user_name(auid if login else euid),
+            pid=pid or None, ppid=ppid or None,
+            processName=Path(exe).name if exe else None,
+            command=command or None, target=exe, exitCode=0,
+        ))
+
+    # ── helpers ──────────────────────────────────────────────────────────────
+
+    def _is_agent(self, uid) -> bool:
+        return self._agent_uid is not None and uid == self._agent_uid
+
+    def _remember_ppid(self, pid: int, ppid: int) -> None:
+        if not pid:
+            return
+        self._ppid[pid] = ppid
+        self._ppid.move_to_end(pid)
+        while len(self._ppid) > _MAX_PID_CACHE:
+            self._ppid.popitem(last=False)
+
+
+class EsloggerCollector(AuditdCollector):
+    """Tails the eslogger log. The file-following (resume offset, partial lines,
+    rotation/truncation) is identical to the auditd tail, so it is reused as is."""
+
+    def __init__(self, path: str = DEFAULT_ES_LOG, *, parser: EsloggerParser | None = None,
+                 state_file: Path | None = None, poll_s: float = 1.0) -> None:
+        super().__init__(
+            path,
+            parser=parser or EsloggerParser(),   # type: ignore[arg-type] — same feed() contract
+            state_file=state_file or (Path.home() / ".agentos" / "activity_eslogger_state.json"),
+            poll_s=poll_s,
+        )

{devops_bot_sdk-1.6.42 → devops_bot_sdk-1.6.46}/sdk/activity/collectors/windows_eventlog.py

@@ -14,6 +14,11 @@ The event parser and the processor are pure; only :class:`WindowsEventLogCollect
 touches the OS. Processes created by SYSTEM / LOCAL SERVICE / NETWORK SERVICE are
 skipped by default (``ignore_system``): they are thousands of events an hour of
 Windows housekeeping that no human or agent did.
+
+The collector's own polling is skipped too: every poll runs ``wevtutil.exe`` from the
+panel process (as the panel's user, not SYSTEM), and each of those is itself a 4688.
+Unfiltered, that is ~8,600 "Administrator ran wevtutil" events a day per VPS, each
+poll recording the previous one.
 """
 from __future__ import annotations
 
@@ -47,6 +52,9 @@ logger = logging.getLogger("sdk.activity.collectors.windows")
 _NS = "{http://schemas.microsoft.com/win/2004/08/events/event}"
 EVENT_IDS = (4688, 4624, 4634, 4647, 4625)
 _MAX_PID_CACHE = 20_000
+#: Executables the collector itself spawns to poll the log.
+_OWN_TOOLS = ("wevtutil.exe",)
+_MAX_OWN_PIDS = 1_000
 
 #: Logon types that are a PERSON at a keyboard / remote desktop.
 _INTERACTIVE = {2: SessionKind.CONSOLE, 11: SessionKind.CONSOLE, 10: SessionKind.RDP}
@@ -123,11 +131,14 @@ class WindowsEventProcessor:
         registry: AgentProcessRegistry | None = None,
         book: SessionBook | None = None,
         ignore_system: bool = True,
+        self_pid: int | None = None,
     ) -> None:
         self._agent_user = agent_user.lower() if agent_user else None
         self._registry = registry or AgentProcessRegistry()
         self._book = book or SessionBook()
         self._ignore_system = ignore_system
+        self._self_pid = os.getpid() if self_pid is None else self_pid
+        self._own: OrderedDict[int, None] = OrderedDict()   # pids of our own polls + children
         self._ppid: OrderedDict[int, int] = OrderedDict()
         self._logons: dict[str, str] = {}              # logon id → session key
         self._kinds: dict[str, SessionKind] = {}       # logon id → login kind
@@ -202,6 +213,9 @@ class WindowsEventProcessor:
         d = ev.data
         pid, ppid = _hex(d.get("NewProcessId")), _hex(d.get("ProcessId"))
         self._remember_ppid(pid, ppid)
+        image = d.get("NewProcessName", "")
+        if self._is_own_poll(pid, ppid, image):
+            return
         logon_id = d.get("SubjectLogonId", "").lower()
         if self._ignore_system and logon_id in _SYSTEM_LOGON_IDS:
             return
@@ -232,7 +246,6 @@ class WindowsEventProcessor:
                 session_key, started=ev.time, verdict=verdict, os_user=user,
             ).agent_run_id
 
-        image = d.get("NewProcessName", "")
         recorder.record_event(ActivityEvent(
             os=Os.WINDOWS, source=Source.WIN_EVENTLOG, category=Category.COMMAND, action="exec",
             occurredAt=ev.time, sessionKey=session_key,
@@ -243,6 +256,20 @@ class WindowsEventProcessor:
             metadata={"parent": d.get("ParentProcessName") or None},
         ))
 
+    def _is_own_poll(self, pid: int, ppid: int, image: str) -> bool:
+        """A ``wevtutil`` this process spawned to poll, or a child of one (its ``conhost``).
+
+        Matched by parent pid AND image name, so anything else the panel spawns —
+        an agent run, ``git``, ``claude`` — is still recorded.
+        """
+        name = image.rsplit("\\", 1)[-1].lower()
+        if not ((ppid == self._self_pid and name in _OWN_TOOLS) or ppid in self._own):
+            return False
+        self._own[pid] = None
+        while len(self._own) > _MAX_OWN_PIDS:
+            self._own.popitem(last=False)
+        return True
+
     def _remember_ppid(self, pid: int, ppid: int) -> None:
         self._ppid[pid] = ppid
         self._ppid.move_to_end(pid)