xybern 2.0.0__tar.gz

xybern-2.0.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: xybern
+Version: 2.0.0
+Summary: Identity & authorisation infrastructure for AI agents — install once, discover every agent, authorise every action.
+Author-email: Xybern <info@xybern.com>
+License: MIT
+Project-URL: Homepage, https://www.xybern.com
+Project-URL: Documentation, https://docs.xybern.com/authorization/sdk
+Keywords: ai,agents,authorization,identity,governance,langchain,crewai,mcp,provenance
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Provides-Extra: crypto
+Requires-Dist: cryptography>=41.0.0; extra == "crypto"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+
+# Xybern
+
+**Identity & authorisation infrastructure for AI agents.** Install once — Xybern
+discovers every AI agent in your system, gives each a cryptographic identity, and
+(when you turn enforcement on) authorises every action *before* it executes.
+
+```bash
+pip install xybern
+xybern login          # browser device-code flow (auto-links your workspace)
+```
+
+```python
+from xybern import auto
+auto.connect()        # discovers frameworks + agents + tools, registers them, instruments them
+```
+
+```
+✓ Detected frameworks: CrewAI, LangGraph, 2 MCP servers
+✓ Found 12 agents · 48 tools
+✓ Registered to workspace "Acme Corp" (each issued a cryptographic identity)
+✓ Mode: OBSERVE — actions logged, nothing blocked yet
+```
+
+## What it does
+
+- **Auto-discovery** — detects and instruments LangChain, CrewAI, OpenAI Agents SDK,
+  MCP servers, LangGraph, AutoGen, Semantic Kernel, LlamaIndex (and FastAPI/Celery).
+  No manual wiring; agents appear in your Xybern dashboard as your app creates them.
+- **Cryptographic identity** — every discovered agent is registered and issued an
+  identity, so its actions are attributable and signable.
+- **Authorisation before execution** — each tool/agent action passes through Xybern's
+  policy engine; `allow` / `block` / `escalate`.
+- **Observe-first & fail-open** — default mode only *logs* (never blocks). When you
+  switch to enforce, the SDK fails open if Xybern is unreachable, so it can't take
+  your agents down.
+- **Privacy** — sends content **hashes** by default, not raw payloads.
+
+## Modes
+
+```python
+auto.connect()                 # OBSERVE (default): log + inventory, never blocks
+auto.connect(mode="enforce")   # authorise actions (allow/block/escalate)
+```
+or persist it: `xybern enforce on` / `xybern enforce off`.
+
+## CLI
+
+```
+xybern login [--api-key xb_...]   # device-code flow, or paste a key / set XYBERN_API_KEY
+xybern agents                     # dry-run: what would be discovered
+xybern status
+xybern enforce on|off
+xybern logout
+```
+
+## Auth options
+
+1. **Device code** — `xybern login` opens a browser; approve + pick a workspace; a
+   scoped key is minted and stored in `~/.xybern/credentials.json`.
+2. **API key** — `xybern login --api-key xb_...`, or `export XYBERN_API_KEY=xb_...`,
+   or `auto.connect(api_key="xb_...")`.
+
+## Configuration
+
+| Option | Default | Meaning |
+| --- | --- | --- |
+| `mode` | `observe` | `observe` (log only) or `enforce` (act on decisions) |
+| `fail_open` | `True` | allow actions through if Xybern is unreachable (enforce mode) |
+| `redact` | `True` | send content hashes instead of raw content |
+| `frameworks` | all | restrict to specific frameworks |
+
+Docs: https://docs.xybern.com/authorization/sdk

xybern-2.0.0/README.md

@@ -0,0 +1,72 @@
+# Xybern
+
+**Identity & authorisation infrastructure for AI agents.** Install once — Xybern
+discovers every AI agent in your system, gives each a cryptographic identity, and
+(when you turn enforcement on) authorises every action *before* it executes.
+
+```bash
+pip install xybern
+xybern login          # browser device-code flow (auto-links your workspace)
+```
+
+```python
+from xybern import auto
+auto.connect()        # discovers frameworks + agents + tools, registers them, instruments them
+```
+
+```
+✓ Detected frameworks: CrewAI, LangGraph, 2 MCP servers
+✓ Found 12 agents · 48 tools
+✓ Registered to workspace "Acme Corp" (each issued a cryptographic identity)
+✓ Mode: OBSERVE — actions logged, nothing blocked yet
+```
+
+## What it does
+
+- **Auto-discovery** — detects and instruments LangChain, CrewAI, OpenAI Agents SDK,
+  MCP servers, LangGraph, AutoGen, Semantic Kernel, LlamaIndex (and FastAPI/Celery).
+  No manual wiring; agents appear in your Xybern dashboard as your app creates them.
+- **Cryptographic identity** — every discovered agent is registered and issued an
+  identity, so its actions are attributable and signable.
+- **Authorisation before execution** — each tool/agent action passes through Xybern's
+  policy engine; `allow` / `block` / `escalate`.
+- **Observe-first & fail-open** — default mode only *logs* (never blocks). When you
+  switch to enforce, the SDK fails open if Xybern is unreachable, so it can't take
+  your agents down.
+- **Privacy** — sends content **hashes** by default, not raw payloads.
+
+## Modes
+
+```python
+auto.connect()                 # OBSERVE (default): log + inventory, never blocks
+auto.connect(mode="enforce")   # authorise actions (allow/block/escalate)
+```
+or persist it: `xybern enforce on` / `xybern enforce off`.
+
+## CLI
+
+```
+xybern login [--api-key xb_...]   # device-code flow, or paste a key / set XYBERN_API_KEY
+xybern agents                     # dry-run: what would be discovered
+xybern status
+xybern enforce on|off
+xybern logout
+```
+
+## Auth options
+
+1. **Device code** — `xybern login` opens a browser; approve + pick a workspace; a
+   scoped key is minted and stored in `~/.xybern/credentials.json`.
+2. **API key** — `xybern login --api-key xb_...`, or `export XYBERN_API_KEY=xb_...`,
+   or `auto.connect(api_key="xb_...")`.
+
+## Configuration
+
+| Option | Default | Meaning |
+| --- | --- | --- |
+| `mode` | `observe` | `observe` (log only) or `enforce` (act on decisions) |
+| `fail_open` | `True` | allow actions through if Xybern is unreachable (enforce mode) |
+| `redact` | `True` | send content hashes instead of raw content |
+| `frameworks` | all | restrict to specific frameworks |
+
+Docs: https://docs.xybern.com/authorization/sdk

xybern-2.0.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xybern"
+version = "2.0.0"
+description = "Identity & authorisation infrastructure for AI agents — install once, discover every agent, authorise every action."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "Xybern", email = "info@xybern.com" }]
+keywords = ["ai", "agents", "authorization", "identity", "governance", "langchain", "crewai", "mcp", "provenance"]
+dependencies = [
+    "requests>=2.25.0",
+]
+
+[project.optional-dependencies]
+# Per-agent cryptographic identity signing (Ed25519). Optional — falls back to
+# unsigned registration if absent.
+crypto = ["cryptography>=41.0.0"]
+dev = ["pytest"]
+
+[project.urls]
+Homepage = "https://www.xybern.com"
+Documentation = "https://docs.xybern.com/authorization/sdk"
+
+[project.scripts]
+xybern = "xybern.cli.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["xybern*"]

xybern-2.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xybern-2.0.0/xybern/__init__.py

@@ -0,0 +1,29 @@
+"""
+Xybern — identity & authorisation infrastructure for AI agents.
+
+Install once; Xybern discovers every AI agent in your system, gives each a
+cryptographic identity, and (when you turn enforcement on) authorises every
+action before it executes.
+
+Quick start::
+
+    from xybern import auto
+    auto.connect()          # uses the key from `xybern login`, env, or config
+
+    # discovers frameworks + agents + tools, registers them to your workspace
+    # (each gets a DID), and instruments them in OBSERVE mode by default.
+
+CLI::
+
+    xybern login            # device-code browser flow (auto-picks your workspace key)
+    xybern agents           # dry-run: show what would be discovered
+    xybern status
+    xybern enforce on       # switch from observe to active authorisation
+"""
+
+from . import auto
+from .config import Config
+
+__version__ = "2.0.0"
+
+__all__ = ["auto", "Config", "__version__"]

xybern-2.0.0/xybern/auto.py

@@ -0,0 +1,167 @@
+"""The one-line entrypoint: discover, register (with identity), instrument.
+
+    from xybern import auto
+    auto.connect()
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+from . import discovery
+from .client import XybernClient
+from .config import Config
+
+log = logging.getLogger("xybern")
+
+
+@dataclass
+class ConnectResult:
+    authenticated: bool
+    mode: str
+    frameworks: List[str] = field(default_factory=list)
+    agents: List[str] = field(default_factory=list)
+    instrumented: List[str] = field(default_factory=list)
+    workspace: Optional[str] = None
+
+    def summary(self) -> str:
+        lines = [
+            f"✓ Detected frameworks: {', '.join(self.frameworks) or 'none'}",
+            f"✓ Found {len(self.agents)} agent(s)/tool(s)",
+        ]
+        if self.authenticated:
+            lines.append(f"✓ Registered to workspace (each issued an identity)")
+            lines.append(f"✓ Mode: {self.mode.upper()}" +
+                         (" — actions logged, nothing blocked yet" if self.mode == "observe" else " — authorising actions"))
+        else:
+            lines.append("⚠ Not connected — run `xybern login` (or set XYBERN_API_KEY) to register + govern")
+        return "\n".join(lines)
+
+
+class _Registrar:
+    """Idempotently maps discovered agents → registered agent_ids (with identity)."""
+    def __init__(self, client: XybernClient, cfg: Config):
+        self.client = client
+        self.cfg = cfg
+        self._by_key: Dict[str, str] = {}     # name|framework -> agent_id
+        self._loaded = False
+
+    def _key(self, name: str, framework: str) -> str:
+        return f"{framework}|{name}".lower()
+
+    def _load_existing(self):
+        if self._loaded or not self.cfg.authenticated:
+            return
+        self._loaded = True
+        try:
+            data = self.client.list_agents()
+            for a in (data.get("agents") or []):
+                self._by_key[self._key(a.get("name", ""), a.get("framework", ""))] = a.get("agent_id")
+        except Exception:
+            pass
+
+    def ensure(self, info: "discovery.AgentInfo") -> Optional[str]:
+        if not self.cfg.authenticated:
+            return None
+        self._load_existing()
+        k = self._key(info.name, info.framework)
+        if k in self._by_key:
+            return self._by_key[k]
+        try:
+            resp = self.client.register_agent(
+                name=info.name, framework=info.framework,
+                capabilities=info.capabilities or [],
+                description=f"Auto-discovered {info.kind} via Xybern SDK",
+            )
+            agent_id = (resp.get("agent") or {}).get("agent_id")
+            if agent_id:
+                self._by_key[k] = agent_id
+            return agent_id
+        except Exception as e:
+            log.debug("xybern: register failed for %s: %s", info.name, e)
+            return None
+
+
+_STATE: Dict = {"connected": False}
+
+
+def connect(api_key: Optional[str] = None, mode: Optional[str] = None,
+            frameworks: Optional[List[str]] = None, instrument: bool = True,
+            **overrides) -> ConnectResult:
+    """Discover agents, register them (with cryptographic identity), and instrument
+    the detected frameworks. OBSERVE mode by default — nothing is ever blocked until
+    you switch to enforce (`xybern enforce on` or mode="enforce")."""
+    cfg = Config.resolve(api_key=api_key, mode=mode, frameworks=frameworks, **overrides)
+    client = XybernClient(cfg)
+
+    from .telemetry import Telemetry
+    tel = Telemetry(client, cfg)
+    tel.start()
+    registrar = _Registrar(client, cfg)
+
+    # 1) inventory whatever already exists, register each
+    found = discovery.discover_all(cfg.frameworks)
+    for a in found:
+        registrar.ensure(a)
+
+    # 2) the action hook used by all framework interceptors
+    def hook(framework, action_type, agent_name, content, metadata) -> bool:
+        return _on_action(cfg, client, tel, registrar, framework, action_type,
+                          agent_name, content, metadata)
+
+    def on_discover(info):
+        registrar.ensure(info)
+
+    instrumented = []
+    if instrument:
+        instrumented = discovery.instrument_all(hook, on_discover, cfg.frameworks)
+
+    _STATE.update({"connected": True, "cfg": cfg, "client": client,
+                   "telemetry": tel, "registrar": registrar})
+
+    return ConnectResult(
+        authenticated=cfg.authenticated, mode=cfg.mode,
+        frameworks=discovery.detected_frameworks(cfg.frameworks),
+        agents=[a.name for a in found], instrumented=instrumented,
+        workspace=cfg.workspace,
+    )
+
+
+def _on_action(cfg, client, tel, registrar, framework, action_type, agent_name,
+               content, metadata) -> bool:
+    """Return True to allow, False to block. OBSERVE always allows (logs only)."""
+    agent_id = None
+    if agent_name:
+        from .discovery import AgentInfo
+        agent_id = registrar.ensure(AgentInfo(name=agent_name, framework=framework))
+
+    if cfg.mode != "enforce":
+        # observe: enqueue, never block
+        if cfg.authenticated:
+            ev = {"action_type": action_type, "agent_id": agent_id,
+                  "metadata": {"framework": framework, **(metadata or {})}}
+            if content is not None:
+                ev["metadata"]["content_sha256"] = hashlib.sha256(
+                    content.encode("utf-8", "replace")).hexdigest()
+            tel.record(ev)
+        return True
+
+    # enforce: synchronous decision, fail-open per config
+    if not cfg.authenticated:
+        return True
+    try:
+        result = client.intercept(action_type=action_type, action_content=content,
+                                  agent_id=agent_id,
+                                  metadata={"framework": framework, **(metadata or {})})
+        decision = result.get("decision", "allow")
+        return decision == "allow"
+    except Exception:
+        return cfg.fail_open
+
+
+def status() -> Dict:
+    return {"connected": _STATE.get("connected", False),
+            "mode": getattr(_STATE.get("cfg"), "mode", None)}

xybern-2.0.0/xybern/cli/__main__.py

@@ -0,0 +1,158 @@
+"""`xybern` command-line interface."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import socket
+import sys
+import time
+
+from ..config import (Config, DEFAULT_BASE_URL, save_credentials, clear_credentials,
+                      set_mode)
+from ..client import XybernClient
+
+
+def _client(api_key=None) -> XybernClient:
+    base = os.environ.get("XYBERN_BASE_URL", DEFAULT_BASE_URL)
+    return XybernClient(Config(api_key=api_key, base_url=base))
+
+
+# ── commands ──────────────────────────────────────────────────────────────────
+
+def cmd_login(args) -> int:
+    base = os.environ.get("XYBERN_BASE_URL", DEFAULT_BASE_URL)
+
+    # Path 1 — explicit/paste key (or env). Validate then save.
+    api_key = args.api_key or os.environ.get("XYBERN_API_KEY")
+    if api_key:
+        cli = _client(api_key)
+        try:
+            cli.whoami()
+        except Exception as e:
+            print(f"✗ Could not validate that API key: {e}", file=sys.stderr)
+            return 1
+        save_credentials(api_key, base_url=base)
+        print("✓ Logged in with API key. Credentials saved to ~/.xybern/credentials.json")
+        return 0
+
+    # Path 2 — device-code browser flow (auto-picks your workspace key)
+    cli = _client()
+    try:
+        start = cli.device_auth_start(hostname=socket.gethostname())
+    except Exception as e:
+        print(f"✗ Device login unavailable ({e}).\n"
+              f"  Use:  xybern login --api-key xb_...   (create a key in your Xybern dashboard)",
+              file=sys.stderr)
+        return 1
+
+    url = start.get("verification_url") or start.get("verification_uri")
+    user_code = start.get("user_code")
+    device_code = start.get("device_code")
+    interval = int(start.get("interval", 5))
+    expires = int(start.get("expires_in", 600))
+
+    print("\nTo authorise this machine, open:\n")
+    print(f"    {url}")
+    print(f"\nand enter the code:  {user_code}\n")
+    try:
+        import webbrowser
+        webbrowser.open(url)
+    except Exception:
+        pass
+
+    print("Waiting for approval…", end="", flush=True)
+    deadline = time.time() + expires
+    while time.time() < deadline:
+        time.sleep(interval)
+        print(".", end="", flush=True)
+        try:
+            poll = cli.device_auth_poll(device_code)
+        except Exception:
+            continue
+        if poll.get("api_key"):
+            save_credentials(poll["api_key"], base_url=base, workspace=poll.get("workspace"))
+            print(f"\n✓ Logged in to workspace {poll.get('workspace') or ''}. "
+                  f"Credentials saved.")
+            return 0
+        if poll.get("status") in ("denied", "expired"):
+            print(f"\n✗ Login {poll['status']}.", file=sys.stderr)
+            return 1
+    print("\n✗ Timed out waiting for approval.", file=sys.stderr)
+    return 1
+
+
+def cmd_logout(args) -> int:
+    clear_credentials()
+    print("✓ Logged out.")
+    return 0
+
+
+def cmd_agents(args) -> int:
+    from .. import discovery
+    fw = discovery.detected_frameworks()
+    found = discovery.discover_all()
+    print(f"✓ Detected frameworks: {', '.join(fw) or 'none'}")
+    print(f"✓ Found {len(found)} agent(s)/tool(s) already instantiated"
+          + ("" if found else " (more appear as your app creates them)"))
+    by_fw = {}
+    for a in found:
+        by_fw.setdefault(a.framework, []).append(a)
+    for f, items in by_fw.items():
+        print(f"  • {f}: " + ", ".join(sorted({i.name for i in items}))[:200])
+    cfg = Config.resolve()
+    if not cfg.authenticated:
+        print("\n⚠ Not connected. Run `xybern login`, then `auto.connect()` in your app "
+              "to register these agents (each gets an identity).")
+    return 0
+
+
+def cmd_status(args) -> int:
+    cfg = Config.resolve()
+    print(f"Base URL:  {cfg.base_url}")
+    print(f"Mode:      {cfg.mode}")
+    print(f"Auth:      {'✓ logged in' if cfg.authenticated else '✗ not logged in'}")
+    if cfg.authenticated:
+        try:
+            n = len((_client(cfg.api_key).list_agents().get('agents') or []))
+            print(f"Workspace: {cfg.workspace or '(linked)'} · {n} registered agent(s)")
+        except Exception as e:
+            print(f"Workspace: (could not reach control plane: {e})")
+    return 0
+
+
+def cmd_enforce(args) -> int:
+    if args.state == "on":
+        set_mode("enforce")
+        print("✓ Enforcement ON — actions will be authorised (allow/block/escalate) on next connect.")
+    else:
+        set_mode("observe")
+        print("✓ Enforcement OFF — observe only (actions logged, nothing blocked).")
+    return 0
+
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(prog="xybern", description="Xybern — identity & authorisation for AI agents")
+    sub = p.add_subparsers(dest="cmd")
+
+    lp = sub.add_parser("login", help="Authenticate this machine (device code, or --api-key)")
+    lp.add_argument("--api-key", help="Use an API key directly instead of the browser flow")
+    lp.set_defaults(func=cmd_login)
+
+    sub.add_parser("logout", help="Remove stored credentials").set_defaults(func=cmd_logout)
+    sub.add_parser("agents", help="Discover agents/tools in this project (dry run)").set_defaults(func=cmd_agents)
+    sub.add_parser("status", help="Show login + mode").set_defaults(func=cmd_status)
+
+    ep = sub.add_parser("enforce", help="Turn enforcement on/off")
+    ep.add_argument("state", choices=["on", "off"])
+    ep.set_defaults(func=cmd_enforce)
+
+    args = p.parse_args(argv)
+    if not getattr(args, "func", None):
+        p.print_help()
+        return 0
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

xybern-2.0.0/xybern/client.py

@@ -0,0 +1,83 @@
+"""Thin REST client for the Xybern control plane."""
+
+from __future__ import annotations
+
+import hashlib
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from .config import Config
+
+
+class XybernClient:
+    def __init__(self, config: Config):
+        self.cfg = config
+        self._session = requests.Session()
+        if config.api_key:
+            self._session.headers.update({"X-API-Key": config.api_key})
+        self._session.headers.update({"User-Agent": "xybern-sdk/2.0"})
+
+    # ── low level ────────────────────────────────────────────────────────────
+    def _url(self, path: str) -> str:
+        return f"{self.cfg.base_url.rstrip('/')}/{path.lstrip('/')}"
+
+    def _post(self, path: str, body: Dict[str, Any]) -> Dict[str, Any]:
+        r = self._session.post(self._url(path), json=body, timeout=self.cfg.timeout)
+        r.raise_for_status()
+        return r.json()
+
+    def _get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        r = self._session.get(self._url(path), params=params or {}, timeout=self.cfg.timeout)
+        r.raise_for_status()
+        return r.json()
+
+    # ── agents / registration ────────────────────────────────────────────────
+    def register_agent(self, name: str, framework: str = "custom",
+                        description: Optional[str] = None,
+                        capabilities: Optional[List[str]] = None,
+                        permissions: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Register (or idempotently re-register) an agent; returns agent + credential."""
+        return self._post("/enforce/agents", {
+            "name": name,
+            "framework": framework,
+            "description": description,
+            "capabilities": capabilities or [],
+            "permissions": permissions or {},
+        })
+
+    def list_agents(self) -> Dict[str, Any]:
+        return self._get("/enforce/agents")
+
+    # ── enforcement ────────────────────────────────────────────────────────────
+    def intercept(self, action_type: str, action_content: Optional[str] = None,
+                  agent_id: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None,
+                  ) -> Dict[str, Any]:
+        """Authorise one action. Respects redact (sends a content hash by default)."""
+        body: Dict[str, Any] = {"action_type": action_type, "agent_id": agent_id,
+                                "metadata": metadata or {}}
+        if action_content is not None:
+            if self.cfg.redact:
+                body["metadata"]["content_sha256"] = hashlib.sha256(
+                    action_content.encode("utf-8", "replace")).hexdigest()
+                body["action_content"] = None
+            else:
+                body["action_content"] = action_content
+        return self._post("/enforce/intercept", body)
+
+    def batch_intercept(self, actions: List[Dict[str, Any]]) -> Dict[str, Any]:
+        return self._post("/enforce/batch", {"actions": actions})
+
+    def list_policies(self) -> Dict[str, Any]:
+        return self._get("/enforce/policies")
+
+    def whoami(self) -> Dict[str, Any]:
+        """Lightweight auth/workspace check (lists agents; 200 => key valid)."""
+        return self._get("/enforce/agents")
+
+    # ── device-code login ──────────────────────────────────────────────────────
+    def device_auth_start(self, hostname: str) -> Dict[str, Any]:
+        return self._post("/auth/device/start", {"hostname": hostname, "client": "xybern-sdk"})
+
+    def device_auth_poll(self, device_code: str) -> Dict[str, Any]:
+        return self._post("/auth/device/poll", {"device_code": device_code})