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

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

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

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

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

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

@@ -51,6 +51,18 @@ sdk/updater.py
 sdk/url_access.py
 sdk/vps_health.py
 sdk/write_hook.py
+sdk/activity/__init__.py
+sdk/activity/classifier.py
+sdk/activity/models.py
+sdk/activity/recorder.py
+sdk/activity/redact.py
+sdk/activity/settings.py
+sdk/activity/shipper.py
+sdk/activity/spool.py
+sdk/activity/collectors/__init__.py
+sdk/activity/collectors/common.py
+sdk/activity/collectors/linux_auditd.py
+sdk/activity/collectors/windows_eventlog.py
 sdk/agents/__init__.py
 sdk/agents/activity.py
 sdk/agents/builder.py
@@ -123,6 +135,9 @@ sdk/ui/static/schedules.html
 sdk/ui/static/setup.html
 sdk/ui/static/styles.css
 sdk/ui/static/tickets.html
+tests/test_activity_collectors.py
+tests/test_activity_core.py
+tests/test_activity_pipeline.py
 tests/test_agent_activity.py
 tests/test_agent_activity_tracking.py
 tests/test_agent_chat_features.py
@@ -178,6 +193,7 @@ tests/test_run_auto_agent_only.py
 tests/test_run_outputs.py
 tests/test_run_verdict_is_honest.py
 tests/test_schedule_api.py
+tests/test_schedule_outputs_and_plans.py
 tests/test_scheduler.py
 tests/test_self_report.py
 tests/test_service_token_warning.py

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

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

@@ -0,0 +1,15 @@
+"""VPS activity audit trail.
+
+Records what happens on the machine the SDK runs on — commands, logins, processes,
+file and network changes, and every agent run / tool call — classifies it HUMAN /
+AGENT / SYSTEM, and ships it to the backend so it is stored against this VPS.
+
+    recorder    the one safe write API (redacts, never raises)
+    spool       durable SQLite queue — rows survive crashes and outages
+    shipper     5-minute flush loop → devops-bot-ai → devops-bot-be
+    classifier  pure human-vs-agent decision, identical on every OS
+    redact      strips secrets from command lines at capture time
+    collectors  per-OS fact gatherers (opt-in: AGENTOS_ACTIVITY_AUDIT=1)
+
+See docs/ACTIVITY_AUDIT.md for the data flow and the OS-side setup.
+"""

devops_bot_sdk-1.6.42/sdk/activity/classifier.py

@@ -0,0 +1,143 @@
+"""Decide whether activity on a VPS was done by a HUMAN, an AGENT, or the SYSTEM.
+
+The label is per SESSION / process tree, not per event: every event in a session
+inherits it. Collectors on each OS gather *facts* about a process (who it
+descends from, which OS user, whether it has a terminal, how its logon started)
+and this module turns those facts into a verdict. Keeping the decision pure — no
+OS calls — means the same rules run, and are tested, identically on Linux,
+Windows and macOS; only the fact-gathering differs per platform.
+
+Signals, strongest first (the confidence is what gets stored and shown):
+
+  1. descends from a process agentos launched ................ AGENT   95
+  2. runs as the dedicated agent OS user ..................... AGENT   90
+  3. an interactive login (SSH / RDP / console) .............. HUMAN   85
+     … a terminal but no recorded login ...................... HUMAN   70
+  4. started by init / service manager / scheduler, no tty ... SYSTEM  80
+  5. none of the above ....................................... UNKNOWN  0
+
+AGENT beats HUMAN on purpose: a person who SSHes in and starts an agent creates an
+agent subtree; the person's session is recorded separately and linked through
+``initiatedByKey`` so "who launched it" is still answerable.
+
+Provenance beats guessing. Anything agentos itself spawns is registered in an
+:class:`AgentProcessRegistry`, which is exact; rows 3-4 are heuristics for
+everything agentos did NOT launch.
+"""
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+
+from sdk.activity.models import ActorType, SessionKind
+
+#: How far up the process tree to walk before giving up (guards against cycles).
+MAX_ANCESTRY_DEPTH = 64
+
+
+@dataclass(frozen=True)
+class ProcessFacts:
+    """What a collector observed about a process, in OS-neutral terms."""
+
+    #: Ancestry reaches a process agentos launched (see AgentProcessRegistry).
+    descends_from_agent: bool = False
+    agent_run_id: str | None = None
+    agent_id: str | None = None
+    #: Runs as the dedicated agent OS user (``agentos``; a local account on Windows).
+    is_agent_os_user: bool = False
+    #: Attached to a terminal / interactive window station.
+    has_tty: bool = False
+    #: How the logon began, when known: SSH, RDP or CONSOLE.
+    login_kind: SessionKind | None = None
+    #: Parent chain ends at init/systemd/cron (Linux), services.exe/svchost or the
+    #: task scheduler (Windows), or launchd (macOS) — with no terminal.
+    spawned_by_service_manager: bool = False
+
+
+@dataclass(frozen=True)
+class Verdict:
+    actor_type: ActorType
+    confidence: int
+    #: Short machine-readable reasons, e.g. ``["ancestry:agentos", "os_user:agentos"]``.
+    reasons: tuple[str, ...] = field(default_factory=tuple)
+    session_kind: SessionKind = SessionKind.UNKNOWN
+
+    def reasons_wire(self) -> dict[str, list[str]]:
+        """Shape stored in ``vps_sessions.actor_reasons``."""
+        return {"signals": list(self.reasons)}
+
+
+def classify(facts: ProcessFacts) -> Verdict:
+    """Apply the signal table to ``facts``."""
+    reasons: list[str] = []
+
+    if facts.descends_from_agent:
+        reasons.append("ancestry:agentos")
+        if facts.is_agent_os_user:
+            reasons.append("os_user:agentos")
+        return Verdict(ActorType.AGENT, 95, tuple(reasons), SessionKind.AGENT_RUN)
+
+    if facts.is_agent_os_user:
+        return Verdict(ActorType.AGENT, 90, ("os_user:agentos",), SessionKind.AGENT_RUN)
+
+    if facts.login_kind in (SessionKind.SSH, SessionKind.RDP, SessionKind.CONSOLE):
+        reasons.append(f"login:{facts.login_kind.value}")
+        if facts.has_tty:
+            reasons.append("tty")
+        return Verdict(ActorType.HUMAN, 85, tuple(reasons), facts.login_kind)
+
+    if facts.has_tty:
+        return Verdict(ActorType.HUMAN, 70, ("tty",), SessionKind.CONSOLE)
+
+    if facts.spawned_by_service_manager:
+        return Verdict(
+            ActorType.SYSTEM, 80, ("parent:service-manager", "no-tty"), SessionKind.SERVICE
+        )
+
+    return Verdict(ActorType.UNKNOWN, 0, (), SessionKind.UNKNOWN)
+
+
+@dataclass(frozen=True)
+class AgentRoot:
+    pid: int
+    run_id: str
+    agent_id: str | None = None
+
+
+class AgentProcessRegistry:
+    """Pids agentos launched itself, so descendants can be attributed EXACTLY.
+
+    ``register`` is called wherever the SDK spawns an agent process (the ``claude -p``
+    subprocess, agentd jobs). Collectors then ask :meth:`lookup` with a pid and a
+    ``parent_of`` function, and get the owning run if any ancestor is a root.
+    """
+
+    def __init__(self) -> None:
+        self._roots: dict[int, AgentRoot] = {}
+
+    def register(self, pid: int, run_id: str, agent_id: str | None = None) -> None:
+        self._roots[pid] = AgentRoot(pid, run_id, agent_id)
+
+    def unregister(self, pid: int) -> None:
+        self._roots.pop(pid, None)
+
+    def lookup(self, pid: int, parent_of: Callable[[int], int | None]) -> AgentRoot | None:
+        """The agent run ``pid`` belongs to, by walking its ancestry, or ``None``.
+
+        ``parent_of(pid)`` returns the parent pid, or ``None``/``0`` at the top. A
+        pid that has already exited can't be walked, so a collector that sees events
+        late should cache ppid at exec time.
+        """
+        seen: set[int] = set()
+        current: int | None = pid
+        for _ in range(MAX_ANCESTRY_DEPTH):
+            if current is None or current <= 0 or current in seen:
+                return None
+            if current in self._roots:
+                return self._roots[current]
+            seen.add(current)
+            current = parent_of(current)
+        return None
+
+    def __len__(self) -> int:
+        return len(self._roots)

devops_bot_sdk-1.6.42/sdk/activity/collectors/__init__.py

@@ -0,0 +1,79 @@
+"""OS-level collectors — opt-in (``AGENTOS_ACTIVITY_AUDIT=1``).
+
+    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.)
+
+``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
+or unsupported, and never raises into the panel.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+from sdk.activity import settings
+from sdk.activity.models import Os, current_os
+
+logger = logging.getLogger("sdk.activity.collectors")
+
+#: Local account agentos runs agents as (see docs/ACTIVITY_AUDIT.md).
+AGENT_OS_USER = "agentos"
+
+
+def make_collector(os_name: Os | None = None) -> Any | None:
+    """The collector for this OS, or ``None`` when there isn't one."""
+    os_name = os_name or current_os()
+    if os_name is Os.LINUX:
+        from sdk.activity.collectors.linux_auditd import AuditdCollector, AuditdParser
+
+        agent_uid: int | None = None
+        try:
+            import pwd
+
+            agent_uid = pwd.getpwnam(AGENT_OS_USER).pw_uid
+        except Exception:  # noqa: BLE001 — no such user (yet): heuristics 1/3/4 still apply
+            agent_uid = None
+        return AuditdCollector(parser=AuditdParser(agent_uid=agent_uid))
+    if os_name is Os.WINDOWS:
+        from sdk.activity.collectors.windows_eventlog import (
+            WindowsEventLogCollector,
+            WindowsEventProcessor,
+        )
+
+        return WindowsEventLogCollector(WindowsEventProcessor(agent_user=AGENT_OS_USER))
+    return None
+
+
+async def run_forever(collector: Any) -> None:
+    """Run a blocking collector in a worker thread until cancelled."""
+    try:
+        await asyncio.to_thread(collector.run)
+    except asyncio.CancelledError:
+        collector.stop()  # the thread exits after its current poll
+        raise
+    except Exception:
+        logger.exception("activity collector crashed")
+
+
+def start() -> asyncio.Task[None] | None:
+    if not (settings.enabled() and settings.audit_enabled()):
+        return None
+    try:
+        collector = make_collector()
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("activity collector could not be created: %s", exc)
+        return None
+    if collector is None:
+        logger.warning(
+            "AGENTOS_ACTIVITY_AUDIT is on but there is no OS collector for %s yet; "
+            "agent runs are still recorded", current_os().value,
+        )
+        return None
+    logger.info("activity collector starting (%s)", type(collector).__name__)
+    return asyncio.ensure_future(run_forever(collector))

devops_bot_sdk-1.6.42/sdk/activity/collectors/common.py

@@ -0,0 +1,98 @@
+"""Session bookkeeping shared by the OS collectors.
+
+A collector turns raw OS records into (a) sessions — logins, and agent-attributed
+process trees — and (b) events inside them. This module owns the part that is the
+same on every OS: deciding a session's label with the classifier, recording it once,
+and keeping the key → verdict map so later events can inherit it.
+
+An AGENT verdict needs an ``agentRunId`` on the wire: devops-bot-be only keeps an
+AGENT claim that points at an AGENT session carrying that run id on the same VPS.
+When agentos launched the process, the run id is the real one (``agent-run:<id>``,
+recorded by the agent runner). When the label came from the OS user alone there is
+no such run, so :meth:`SessionBook.ensure` synthesises one (``os:<session key>``) and
+records the session that backs it — the claim is then self-consistent and the
+reason it was made (``os_user:agentos``) is kept in ``actorReasons``.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from sdk.activity import recorder
+from sdk.activity.classifier import Verdict
+from sdk.activity.models import ActivitySession, ActorType, SessionKind
+
+
+@dataclass(frozen=True)
+class SessionInfo:
+    key: str
+    verdict: Verdict
+    kind: SessionKind
+    agent_run_id: str | None
+
+
+class SessionBook:
+    """Tracks sessions a collector has already recorded, by key."""
+
+    def __init__(self) -> None:
+        self._sessions: dict[str, SessionInfo] = {}
+
+    def get(self, key: str) -> SessionInfo | None:
+        return self._sessions.get(key)
+
+    def ensure(
+        self,
+        key: str,
+        *,
+        started: float,
+        verdict: Verdict,
+        kind: SessionKind | None = None,
+        os_user: str | None = None,
+        remote_ip: str | None = None,
+        agent_run_id: str | None = None,
+        agent_id: str | None = None,
+        initiated_by_key: str | None = None,
+    ) -> SessionInfo:
+        """Record the session the first time it is seen; return it either way."""
+        known = self._sessions.get(key)
+        if known:
+            return known
+
+        run_id = agent_run_id
+        if verdict.actor_type is ActorType.AGENT and not run_id:
+            run_id = f"os:{key}"  # see module docstring
+
+        info = SessionInfo(key, verdict, kind or verdict.session_kind, run_id)
+        self._sessions[key] = info
+        recorder.record_session(
+            ActivitySession(
+                externalKey=key,
+                startedAt=started,
+                kind=info.kind,
+                actorType=verdict.actor_type,
+                actorConfidence=verdict.confidence,
+                actorReasons=verdict.reasons_wire(),
+                osUser=os_user,
+                remoteIp=remote_ip,
+                agentRunId=run_id,
+                agentId=agent_id,
+                initiatedByKey=initiated_by_key,
+            )
+        )
+        return info
+
+    def end(self, key: str, ended: float) -> None:
+        """Close a session. A no-op for a session we never saw open."""
+        info = self._sessions.pop(key, None)
+        if info is None:
+            return
+        recorder.record_session(
+            ActivitySession(
+                externalKey=key,
+                startedAt=ended,  # ignored by the backend on update; the model requires it
+                kind=info.kind,
+                actorType=info.verdict.actor_type,
+                actorConfidence=info.verdict.confidence,
+                agentRunId=info.agent_run_id,
+                endedAt=ended,
+            )
+        )