agent-brain-uds 10.1.2__tar.gz

agent_brain_uds-10.1.2/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.1
+Name: agent-brain-uds
+Version: 10.1.2
+Summary: Agent Brain UDS - Unix-domain-socket transport for Agent Brain (socket path resolution, permission validation, httpx UDS client factory)
+Home-page: https://github.com/SpillwaveSolutions/agent-brain
+License: MIT
+Keywords: agent-brain,uds,unix-domain-socket,transport,httpx,ipc
+Author: Spillwave Solutions
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: httpx (>=0.28.0,<0.29.0)
+Project-URL: Documentation, https://github.com/SpillwaveSolutions/agent-brain/wiki
+Project-URL: Repository, https://github.com/SpillwaveSolutions/agent-brain
+Description-Content-Type: text/markdown
+
+# agent-brain-uds
+
+Unix-domain-socket transport for [Agent Brain](https://github.com/SpillwaveSolutions/agent-brain).
+
+**Client-side only.** This package provides:
+
+- Socket path resolution (`resolve_socket_path`) consistent with `agent-brain-server`'s state-dir layout.
+- Permission validation (`validate_socket`) — owner-UID match, no group/world bits, no-symlink check.
+- `httpx`-compatible client factory (`make_client` / `make_async_client`) speaking HTTP/1.1 over UDS.
+
+The corresponding server-side bind (`agent_brain_server.api.uds_bind`) lives in `agent-brain-server` to keep the dep direction acyclic.
+
+## Status
+
+Phase 0 scaffold (10.0.7) — public surface lands in Phase 1.
+See [`docs/plans/2026-05-28-mcp-uds-transport-design.md`](../docs/plans/2026-05-28-mcp-uds-transport-design.md).
+
+## License
+
+MIT
+

agent_brain_uds-10.1.2/README.md

@@ -0,0 +1,20 @@
+# agent-brain-uds
+
+Unix-domain-socket transport for [Agent Brain](https://github.com/SpillwaveSolutions/agent-brain).
+
+**Client-side only.** This package provides:
+
+- Socket path resolution (`resolve_socket_path`) consistent with `agent-brain-server`'s state-dir layout.
+- Permission validation (`validate_socket`) — owner-UID match, no group/world bits, no-symlink check.
+- `httpx`-compatible client factory (`make_client` / `make_async_client`) speaking HTTP/1.1 over UDS.
+
+The corresponding server-side bind (`agent_brain_server.api.uds_bind`) lives in `agent-brain-server` to keep the dep direction acyclic.
+
+## Status
+
+Phase 0 scaffold (10.0.7) — public surface lands in Phase 1.
+See [`docs/plans/2026-05-28-mcp-uds-transport-design.md`](../docs/plans/2026-05-28-mcp-uds-transport-design.md).
+
+## License
+
+MIT

agent_brain_uds-10.1.2/agent_brain_uds/__init__.py

@@ -0,0 +1,62 @@
+"""Agent Brain UDS — Unix-domain-socket transport for Agent Brain.
+
+Client-side only. See docs/plans/2026-05-28-mcp-uds-transport-design.md §4.1.
+
+Public surface:
+
+- :func:`resolve_socket_path` — Resolve the canonical UDS socket path.
+- :func:`validate_socket` — Validate socket file ownership and permissions.
+- :func:`make_client` / :func:`make_async_client` — ``httpx`` clients
+  pre-configured for UDS transport.
+- :class:`AgentBrainUdsError` and subclasses — Exception hierarchy.
+
+The server-side bind helper lives inside ``agent_brain_server`` to keep
+the dependency direction acyclic (server has no upward deps).
+"""
+
+from .client import (
+    BASE_URL,
+    DEFAULT_TIMEOUT,
+    make_async_client,
+    make_client,
+)
+from .errors import (
+    AgentBrainUdsError,
+    SocketNotFoundError,
+    SocketPathTooLongError,
+    SocketPermissionError,
+    SocketStaleError,
+)
+from .paths import (
+    MAX_SOCKET_PATH_BYTES,
+    POINTER_FILE_NAME,
+    SOCKET_FILE_NAME,
+    STATE_DIR_NAME,
+    resolve_socket_path,
+    resolve_state_dir,
+    write_pointer_file,
+)
+from .permissions import validate_socket
+
+__version__ = "10.1.2"
+
+__all__ = [
+    "BASE_URL",
+    "DEFAULT_TIMEOUT",
+    "MAX_SOCKET_PATH_BYTES",
+    "POINTER_FILE_NAME",
+    "SOCKET_FILE_NAME",
+    "STATE_DIR_NAME",
+    "AgentBrainUdsError",
+    "SocketNotFoundError",
+    "SocketPathTooLongError",
+    "SocketPermissionError",
+    "SocketStaleError",
+    "__version__",
+    "make_async_client",
+    "make_client",
+    "resolve_socket_path",
+    "resolve_state_dir",
+    "validate_socket",
+    "write_pointer_file",
+]

agent_brain_uds-10.1.2/agent_brain_uds/client.py

@@ -0,0 +1,84 @@
+"""``httpx`` client factory for UDS transport.
+
+Returns a configured ``httpx.Client`` / ``httpx.AsyncClient`` that speaks
+HTTP/1.1 over the project's UDS socket. The ``base_url`` is a placeholder
+(``http://agent-brain``) because ``httpx`` requires a URL even though UDS
+ignores the host component — using a fixed sentinel makes log messages
+self-documenting.
+
+The client validates socket permissions on construction so a stale or
+hijacked socket fails loud immediately, not on the first request.
+
+See docs/plans/2026-05-28-mcp-uds-transport-design.md §6.3.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import httpx
+
+from .paths import resolve_socket_path
+from .permissions import validate_socket
+
+#: Sentinel base URL that ends up in logs / error messages.
+BASE_URL = "http://agent-brain"
+
+#: Default request timeout (seconds). Overridable per call site.
+DEFAULT_TIMEOUT = 30.0
+
+
+def _resolve_path(
+    state_dir: Path | None,
+    socket_path: Path | None,
+) -> Path:
+    """Decide which socket path to use.
+
+    Precedence: explicit ``socket_path`` argument → ``AGENT_BRAIN_UDS_PATH``
+    env var → ``resolve_socket_path(state_dir)``.
+    """
+    if socket_path is not None:
+        return socket_path
+    env_path = os.environ.get("AGENT_BRAIN_UDS_PATH")
+    if env_path:
+        return Path(env_path).expanduser()
+    return resolve_socket_path(state_dir)
+
+
+def make_client(
+    *,
+    state_dir: Path | None = None,
+    socket_path: Path | None = None,
+    timeout: float = DEFAULT_TIMEOUT,
+) -> httpx.Client:
+    """Return a synchronous ``httpx.Client`` configured for UDS.
+
+    Args:
+        state_dir: Override the state-directory resolver. Defaults to
+            ``AGENT_BRAIN_STATE_DIR`` env var or CWD lookup.
+        socket_path: Override the entire path-resolution chain.
+        timeout: HTTP request timeout in seconds.
+
+    Raises:
+        SocketNotFoundError: when the resolved socket does not exist.
+        SocketPermissionError: when the socket fails the permission checks
+            in :mod:`agent_brain_uds.permissions`.
+    """
+    path = _resolve_path(state_dir, socket_path)
+    validate_socket(path)
+    transport = httpx.HTTPTransport(uds=str(path))
+    return httpx.Client(transport=transport, base_url=BASE_URL, timeout=timeout)
+
+
+def make_async_client(
+    *,
+    state_dir: Path | None = None,
+    socket_path: Path | None = None,
+    timeout: float = DEFAULT_TIMEOUT,
+) -> httpx.AsyncClient:
+    """Async counterpart of :func:`make_client`."""
+    path = _resolve_path(state_dir, socket_path)
+    validate_socket(path)
+    transport = httpx.AsyncHTTPTransport(uds=str(path))
+    return httpx.AsyncClient(transport=transport, base_url=BASE_URL, timeout=timeout)

agent_brain_uds-10.1.2/agent_brain_uds/errors.py

@@ -0,0 +1,74 @@
+"""Exception hierarchy for agent-brain-uds.
+
+Each error carries the resolved socket path and a remediation hint so the
+caller (CLI, MCP server, or third-party) can surface an actionable message
+to the user without re-implementing the diagnostics.
+
+See docs/plans/2026-05-28-mcp-uds-transport-design.md §6.7.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+class AgentBrainUdsError(Exception):
+    """Base class for all agent-brain-uds errors.
+
+    Subclasses carry a ``socket_path`` attribute (when known) and a
+    ``remediation`` hint that callers can show to the user.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        socket_path: Path | None = None,
+        remediation: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.socket_path = socket_path
+        self.remediation = remediation
+
+    def __str__(self) -> str:
+        parts = [super().__str__()]
+        if self.socket_path is not None:
+            parts.append(f"(socket: {self.socket_path})")
+        if self.remediation:
+            parts.append(f"\n  → {self.remediation}")
+        return " ".join(parts)
+
+
+class SocketNotFoundError(AgentBrainUdsError):
+    """No socket file at the resolved path.
+
+    Most common cause: the server has not been started with ``--uds``.
+    """
+
+
+class SocketStaleError(AgentBrainUdsError):
+    """Socket file exists but no listener is bound.
+
+    Typically left over from a crashed server process. The server's
+    own bind helper unlinks stale sockets on startup, so this should
+    be rare in practice.
+    """
+
+
+class SocketPermissionError(AgentBrainUdsError):
+    """Socket file or its parent directory has unsafe permissions.
+
+    Raised when the socket file is owned by a different UID, has
+    group/world readable bits set, is a symlink, or its parent
+    directory is not mode 0700.
+    """
+
+
+class SocketPathTooLongError(AgentBrainUdsError):
+    """Resolved socket path exceeds the OS sockaddr_un limit.
+
+    UDS paths are limited to ~104 bytes on macOS/BSD and ~108 on Linux.
+    The resolver falls back to ``/tmp/agent-brain-<sha8>.sock`` and writes
+    a pointer file; this error is raised only if even the fallback
+    cannot be used.
+    """

agent_brain_uds-10.1.2/agent_brain_uds/paths.py

@@ -0,0 +1,200 @@
+"""Socket path resolution for agent-brain-uds.
+
+Mirrors the state-directory lookup in ``agent_brain_server.runtime`` /
+``agent_brain_server.storage_paths`` so client and server agree on where
+the socket lives. Handles the platform sockaddr_un length limit by
+falling back to a short ``/tmp`` path and writing a pointer file inside
+the state directory.
+
+See docs/plans/2026-05-28-mcp-uds-transport-design.md §6.1.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import stat
+from pathlib import Path
+
+from .errors import SocketPathTooLongError, SocketPermissionError
+
+#: Default state-directory name. Mirrors ``STATE_DIR_NAME`` in the server.
+STATE_DIR_NAME = ".agent-brain"
+
+#: Default socket file name inside the state directory.
+SOCKET_FILE_NAME = "agent-brain.sock"
+
+#: Pointer-file name written alongside the canonical socket location when
+#: the canonical path exceeds the platform limit. Contains the real
+#: (short) socket path, one line, UTF-8.
+POINTER_FILE_NAME = "agent-brain.sock.path"
+
+#: Conservative sockaddr_un limit. macOS/BSD cap is 104 bytes; Linux is 108.
+#: We use the smaller value so paths work on every supported platform.
+MAX_SOCKET_PATH_BYTES = 104
+
+
+def _short_fallback_path(state_dir: Path) -> Path:
+    """Return a short ``/tmp`` socket path derived from the state-dir hash.
+
+    The hash makes the fallback deterministic per project, so concurrent
+    instances in different projects do not collide.
+    """
+    digest = hashlib.sha256(str(state_dir.resolve()).encode("utf-8")).hexdigest()[:8]
+    return Path("/tmp") / f"agent-brain-{digest}.sock"
+
+
+def resolve_state_dir(state_dir: Path | None = None) -> Path:
+    """Resolve the state directory using the same precedence as the server.
+
+    Order:
+
+    1. Explicit ``state_dir`` argument.
+    2. ``AGENT_BRAIN_STATE_DIR`` environment variable.
+    3. ``<cwd>/.agent-brain/`` if it exists.
+    4. Walk up from ``cwd`` looking for ``.agent-brain/``.
+    5. Fall back to ``<cwd>/.agent-brain/`` (does not need to exist —
+       the server creates it).
+
+    Returns:
+        The resolved state-directory path (not guaranteed to exist).
+    """
+    if state_dir is not None:
+        return state_dir.resolve()
+
+    env_dir = os.environ.get("AGENT_BRAIN_STATE_DIR")
+    if env_dir:
+        return Path(env_dir).resolve()
+
+    cwd = Path.cwd().resolve()
+    candidate = cwd / STATE_DIR_NAME
+    if candidate.is_dir():
+        return candidate
+
+    # Walk upward looking for an existing .agent-brain/ directory.
+    for parent in cwd.parents:
+        candidate = parent / STATE_DIR_NAME
+        if candidate.is_dir():
+            return candidate
+
+    # Default: a (possibly non-existent) .agent-brain/ in the current dir.
+    return cwd / STATE_DIR_NAME
+
+
+def resolve_socket_path(state_dir: Path | None = None) -> Path:
+    """Resolve the UDS socket path for the given state directory.
+
+    Reads a pointer file first if present (long-path fallback), then
+    falls back to ``<state_dir>/agent-brain.sock``. If even the canonical
+    path is too long for the platform, returns the short ``/tmp`` fallback
+    (the server is responsible for writing the pointer file when it binds).
+
+    Raises:
+        SocketPathTooLongError: when even the ``/tmp`` fallback exceeds
+            the platform limit (essentially impossible, but guarded for
+            completeness).
+    """
+    resolved_state_dir = resolve_state_dir(state_dir)
+
+    # If a previous server run dropped a pointer file, honor it — but
+    # validate it first (plan §8). The pointer file is a privilege
+    # boundary: whoever writes it controls every client's destination.
+    pointer = resolved_state_dir / POINTER_FILE_NAME
+    target = _read_pointer_file(pointer)
+    if target is not None:
+        if len(str(target).encode("utf-8")) >= MAX_SOCKET_PATH_BYTES:
+            raise SocketPathTooLongError(
+                "Pointer-file target exceeds platform socket-path limit.",
+                socket_path=target,
+                remediation=(
+                    "Delete the pointer file and re-bind the server with "
+                    "AGENT_BRAIN_UDS_PATH set to a path under 104 bytes."
+                ),
+            )
+        return target
+
+    canonical = resolved_state_dir / SOCKET_FILE_NAME
+    if len(str(canonical).encode("utf-8")) < MAX_SOCKET_PATH_BYTES:
+        return canonical
+
+    # Canonical path is too long; use the short fallback.
+    fallback = _short_fallback_path(resolved_state_dir)
+    if len(str(fallback).encode("utf-8")) >= MAX_SOCKET_PATH_BYTES:
+        raise SocketPathTooLongError(
+            "Both canonical and /tmp fallback paths exceed platform limit.",
+            socket_path=fallback,
+            remediation=("Set AGENT_BRAIN_UDS_PATH to a path shorter than 104 bytes."),
+        )
+    return fallback
+
+
+def _read_pointer_file(pointer: Path) -> Path | None:
+    """Return the validated socket path from ``pointer`` or ``None``.
+
+    Defenses (plan §8 — Phase 5):
+
+    * ``os.lstat`` instead of ``Path.is_file`` so a symlink at the
+      pointer path is detected, not silently followed.
+    * Pointer must be a regular file; symlinks / sockets / fifos / dirs
+      are rejected outright.
+    * Pointer contents must be an absolute path with no embedded null
+      bytes.
+
+    ``validate_socket(...)`` still runs on the returned path before any
+    connection, so this is defense-in-depth — the goal is to fail fast
+    on obviously attacker-controlled inputs rather than to substitute
+    for the socket-level checks.
+    """
+    try:
+        pst = os.lstat(pointer)
+    except FileNotFoundError:
+        return None
+
+    if stat.S_ISLNK(pst.st_mode):
+        raise SocketPermissionError(
+            "Refusing to follow symlinked pointer file.",
+            socket_path=pointer,
+            remediation=(
+                f"Delete {pointer} (it is a symlink) and re-bind the "
+                "server, which will write a real pointer file."
+            ),
+        )
+    if not stat.S_ISREG(pst.st_mode):
+        raise SocketPermissionError(
+            "Pointer file is not a regular file.",
+            socket_path=pointer,
+            remediation=f"Delete {pointer} and re-bind the server.",
+        )
+
+    raw = pointer.read_bytes()
+    if b"\x00" in raw:
+        raise SocketPermissionError(
+            "Pointer file contains an embedded null byte; refusing to parse.",
+            socket_path=pointer,
+            remediation=f"Delete {pointer} and re-bind the server.",
+        )
+
+    target_str = raw.decode("utf-8", errors="strict").strip()
+    target = Path(target_str)
+    if not target.is_absolute():
+        raise SocketPermissionError(
+            f"Pointer-file target {target_str!r} is not an absolute path.",
+            socket_path=target,
+            remediation=(
+                f"Delete {pointer} and re-bind the server (or set "
+                "AGENT_BRAIN_UDS_PATH to an absolute path under 104 bytes)."
+            ),
+        )
+    return target
+
+
+def write_pointer_file(state_dir: Path, real_socket_path: Path) -> Path:
+    """Write the pointer file used by long-path fallback.
+
+    Called by the server when binding to a ``/tmp`` fallback socket so
+    later clients can discover the real socket without recomputing.
+    """
+    state_dir.mkdir(parents=True, exist_ok=True)
+    pointer = state_dir / POINTER_FILE_NAME
+    pointer.write_text(str(real_socket_path))
+    return pointer

agent_brain_uds-10.1.2/agent_brain_uds/permissions.py

@@ -0,0 +1,110 @@
+"""Socket permission validation for agent-brain-uds.
+
+Filesystem permissions are the auth model for local UDS: a socket file
+that is mode 0600 owned by the current user is reachable only by that
+user. We enforce that explicitly on connect so a symlink-hijack or a
+world-readable socket fails loud instead of leaking traffic.
+
+Adversarial test coverage lands in Phase 5 (plan §13). Phase 1 ships
+the happy-path and basic rejection logic that those tests build on.
+
+See docs/plans/2026-05-28-mcp-uds-transport-design.md §6.5 / §8.
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+from pathlib import Path
+
+from .errors import SocketNotFoundError, SocketPermissionError
+
+#: Mode bits we refuse to accept on the socket file (group + world rwx).
+FORBIDDEN_SOCKET_BITS = stat.S_IRWXG | stat.S_IRWXO  # 0o077
+
+#: Mode we require on the parent directory of the socket file.
+REQUIRED_PARENT_DIR_MODE = 0o700
+
+
+def validate_socket(path: Path) -> None:
+    """Validate that a UDS socket file is safe for the current user to connect.
+
+    Checks (in order):
+
+    1. The path is not a symlink (``os.lstat``).
+    2. The path exists.
+    3. The path is a socket file (``S_ISSOCK``).
+    4. The path is owned by the current UID.
+    5. The path has no group or world permission bits set.
+    6. The parent directory is mode ``0700``.
+
+    Raises:
+        SocketNotFoundError: when the path does not exist.
+        SocketPermissionError: when any safety check fails.
+    """
+    # Use lstat to detect symlinks without following them. A symlink at
+    # the socket path is a classic privilege-escalation hook.
+    try:
+        st = os.lstat(path)
+    except FileNotFoundError as exc:
+        raise SocketNotFoundError(
+            f"No socket file at {path}.",
+            socket_path=path,
+            remediation=(
+                "Start the server with `agent-brain start --uds`, or set "
+                "AGENT_BRAIN_UDS_PATH to point at an existing socket."
+            ),
+        ) from exc
+
+    if stat.S_ISLNK(st.st_mode):
+        raise SocketPermissionError(
+            "Refusing to connect: socket path is a symlink.",
+            socket_path=path,
+            remediation=(
+                "Inspect the symlink target; if expected, delete the symlink "
+                "and re-bind the server, which will create a real socket file."
+            ),
+        )
+
+    if not stat.S_ISSOCK(st.st_mode):
+        raise SocketPermissionError(
+            "Refusing to connect: path exists but is not a socket file.",
+            socket_path=path,
+            remediation=(
+                "Delete or move the path and re-bind the server to recreate "
+                "the socket cleanly."
+            ),
+        )
+
+    current_uid = os.getuid()
+    if st.st_uid != current_uid:
+        raise SocketPermissionError(
+            f"Refusing to connect: socket owned by uid {st.st_uid}, "
+            f"current uid is {current_uid}.",
+            socket_path=path,
+            remediation=(
+                "Confirm you started the server as the current user, or "
+                "use sudo -u to run as the socket owner."
+            ),
+        )
+
+    if st.st_mode & FORBIDDEN_SOCKET_BITS:
+        raise SocketPermissionError(
+            f"Refusing to connect: socket mode {stat.S_IMODE(st.st_mode):#o} "
+            "includes group or world bits.",
+            socket_path=path,
+            remediation=(
+                "Re-bind the server (the bind helper chmod 0600s the socket); "
+                "or chmod 600 the existing socket if the server is trustworthy."
+            ),
+        )
+
+    parent_st = os.lstat(path.parent)
+    parent_mode = stat.S_IMODE(parent_st.st_mode)
+    if parent_mode != REQUIRED_PARENT_DIR_MODE:
+        raise SocketPermissionError(
+            f"Refusing to connect: parent directory mode is {parent_mode:#o}, "
+            f"expected {REQUIRED_PARENT_DIR_MODE:#o}.",
+            socket_path=path,
+            remediation=(f"chmod 700 {path.parent} and re-bind the server."),
+        )

agent_brain_uds-10.1.2/pyproject.toml

@@ -0,0 +1,61 @@
+[tool.poetry]
+name = "agent-brain-uds"
+version = "10.1.2"
+description = "Agent Brain UDS - Unix-domain-socket transport for Agent Brain (socket path resolution, permission validation, httpx UDS client factory)"
+authors = ["Spillwave Solutions"]
+readme = "README.md"
+license = "MIT"
+homepage = "https://github.com/SpillwaveSolutions/agent-brain"
+repository = "https://github.com/SpillwaveSolutions/agent-brain"
+documentation = "https://github.com/SpillwaveSolutions/agent-brain/wiki"
+keywords = ["agent-brain", "uds", "unix-domain-socket", "transport", "httpx", "ipc"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: POSIX",
+]
+packages = [{include = "agent_brain_uds"}]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+httpx = "^0.28.0"
+# agent-brain-rag dependency added in Phase 1 when models are imported.
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.0"
+pytest-asyncio = "^0.24.0"
+pytest-cov = "^6.0.0"
+black = "^24.10.0"
+ruff = "^0.8.0"
+mypy = "^1.13.0"
+# Roundtrip test spawns a minimal ASGI app bound to a UDS socket via uvicorn.
+uvicorn = "^0.32.0"
+starlette = "^0.41.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 88
+target-version = ['py310']
+
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "N", "UP", "B", "C4"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"