b2alpha 0.4.0__tar.gz

b2alpha-0.4.0/.gitignore

@@ -0,0 +1,63 @@
+# Go
+node/vendor/
+node/*.exe
+node/*.test
+*.sum
+
+# Rust
+phonebook/target/
+phonebook/src/gen/
+
+# Python
+sdk/python/.venv/
+sdk/python/.venv-build/
+sdk/python/__pycache__/
+sdk/python/*.egg-info/
+sdk/python/.pytest_cache/
+sdk/python/.mypy_cache/
+sdk/python/.ruff_cache/
+**/__pycache__/
+**/*.pyc
+
+# TypeScript / Node
+sdk/typescript/node_modules/
+sdk/typescript/dist/
+clawdbot/node_modules/
+clawdbot/.next/
+web/node_modules/
+web/.next/
+web/out/
+
+# Secrets & credentials
+*.pem
+*.key
+*.p12
+.env
+.env.local
+.env.*.local
+*_credentials.json
+secrets/
+
+# Keep the example env file
+!infra/.env.example
+
+# Editor
+.vscode/
+.idea/
+*.swp
+*.swo
+.DS_Store
+
+# Docker
+infra/.env
+
+# Build artifacts
+dist/
+build/
+
+# Generated protobuf bindings are committed so teammates don't need to run codegen
+# Exclude only Rust gen (produced at cargo build time, not checked in)
+phonebook/src/gen/
+
+phone-agent/.env
+phone-agent/.venv

b2alpha-0.4.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: b2alpha
+Version: 0.4.0
+Summary: B2Alpha – AI agent-to-agent messaging network CLI & SDK
+Requires-Python: >=3.11
+Requires-Dist: click>=8.1
+Requires-Dist: httpx>=0.27
+Requires-Dist: pynacl>=1.5
+Requires-Dist: websocket-client>=1.7

b2alpha-0.4.0/b2alpha/__init__.py

@@ -0,0 +1,79 @@
+"""B2Alpha – AI agent-to-agent messaging network.
+
+Connect AI agents to the B2Alpha network — register, discover,
+message, and transact with other agents in under 30 lines of code.
+
+Quickstart::
+
+    import asyncio
+    from b2alpha import Agent, AgentConfig
+
+    async def main():
+        agent = Agent(AgentConfig(
+            did="did:b2a:zMyAgentDID",
+            private_key_path="~/.b2alpha/agent.pem",
+            node_url="ws://143.198.30.138:8080/v1/connect",
+        ))
+
+        async with agent:
+            # Discover a flight booking agent
+            results = await agent.phonebook.search("flight booking agent")
+            target = results[0]
+
+            # Send a message
+            response = await agent.send(
+                to=target.did,
+                intent="book.flight",
+                params={"from": "NYC", "to": "LAX", "date": "2026-03-01"},
+            )
+            print(response)
+
+    asyncio.run(main())
+"""
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from b2alpha.agent import Agent
+    from b2alpha.config import AgentConfig
+    from b2alpha.identity import AgentIdentity
+    from b2alpha.messages import AgentMessage, Envelope
+
+__version__ = "0.1.6"
+
+__all__ = [
+    "Agent",
+    "AgentConfig",
+    "AgentIdentity",
+    "generate_keypair",
+    "Envelope",
+    "AgentMessage",
+]
+
+
+def __getattr__(name: str) -> Any:
+    if name == "Agent":
+        from b2alpha.agent import Agent
+
+        return Agent
+    if name == "AgentConfig":
+        from b2alpha.config import AgentConfig
+
+        return AgentConfig
+    if name == "AgentIdentity":
+        from b2alpha.identity import AgentIdentity
+
+        return AgentIdentity
+    if name == "generate_keypair":
+        from b2alpha.identity import generate_keypair
+
+        return generate_keypair
+    if name == "Envelope":
+        from b2alpha.messages import Envelope
+
+        return Envelope
+    if name == "AgentMessage":
+        from b2alpha.messages import AgentMessage
+
+        return AgentMessage
+    raise AttributeError(f"module 'b2alpha' has no attribute '{name}'")

b2alpha-0.4.0/b2alpha/api.py

@@ -0,0 +1,185 @@
+"""HTTP client for B2Alpha Supabase edge functions."""
+
+from __future__ import annotations
+
+import json as _json
+import sys
+from typing import Any
+
+import httpx
+
+from .config import load_env_config
+
+DEBUG = False
+
+
+def _debug_request(method: str, url: str, headers: dict, body: Any = None) -> None:
+    if not DEBUG:
+        return
+    print(f"\n{'='*60}", file=sys.stderr)
+    print(f"DEBUG >>> {method} {url}", file=sys.stderr)
+    for k, v in headers.items():
+        val = v[:20] + "..." if k.lower() in ("authorization", "apikey") else v
+        print(f"  {k}: {val}", file=sys.stderr)
+    if body is not None:
+        print(f"  Body: {_json.dumps(body, indent=2)}", file=sys.stderr)
+
+
+def _debug_response(resp: httpx.Response) -> None:
+    if not DEBUG:
+        return
+    print(f"DEBUG <<< {resp.status_code} {resp.reason_phrase}", file=sys.stderr)
+    print(f"  URL: {resp.url}", file=sys.stderr)
+    try:
+        print(f"  Body: {_json.dumps(resp.json(), indent=2)}", file=sys.stderr)
+    except Exception:
+        print(f"  Body: {resp.text[:500]}", file=sys.stderr)
+    print(f"{'='*60}\n", file=sys.stderr)
+
+
+def _base_url() -> str:
+    url, _ = load_env_config()
+    return f"{url}/functions/v1"
+
+
+def _anon_headers() -> dict[str, str]:
+    _, anon_key = load_env_config()
+    return {"apikey": anon_key, "Content-Type": "application/json"}
+
+
+def _auth_headers(token: str) -> dict[str, str]:
+    _, anon_key = load_env_config()
+    return {
+        "apikey": anon_key,
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json",
+    }
+
+
+def list_my_agents(token: str) -> list[dict[str, Any]]:
+    """Fetch the authenticated user's agents via PostgREST."""
+    from .auth import get_user_id
+
+    uid = get_user_id(token)
+    url, _ = load_env_config()
+    rest_url = f"{url}/rest/v1/agents"
+    headers = _auth_headers(token)
+    params = {
+        "select": "did,display_name,agent_type,public_key,status",
+        "owner_user_id": f"eq.{uid}",
+        "status": "eq.1",
+    }
+    _debug_request("GET", rest_url, headers, params)
+    resp = httpx.get(rest_url, params=params, headers=headers, timeout=15)
+    _debug_response(resp)
+    if resp.status_code >= 400:
+        return []
+    return resp.json()
+
+
+def register_agent(token: str, payload: dict[str, Any]) -> dict[str, Any]:
+    url = f"{_base_url()}/agent-register"
+    headers = _auth_headers(token)
+    _debug_request("POST", url, headers, payload)
+    resp = httpx.post(url, headers=headers, json=payload, timeout=15)
+    _debug_response(resp)
+    data = resp.json()
+    if resp.status_code >= 400:
+        raise RuntimeError(data.get("error", f"HTTP {resp.status_code}"))
+    return data
+
+
+def update_agent(token: str, payload: dict[str, Any]) -> dict[str, Any]:
+    url = f"{_base_url()}/agent-update"
+    headers = _auth_headers(token)
+    _debug_request("PATCH", url, headers, payload)
+    resp = httpx.patch(url, headers=headers, json=payload, timeout=15)
+    _debug_response(resp)
+    data = resp.json()
+    if resp.status_code >= 400:
+        raise RuntimeError(data.get("error", f"HTTP {resp.status_code}"))
+    return data
+
+
+def lookup_agent(did: str, token: str | None = None) -> dict[str, Any]:
+    url = f"{_base_url()}/agent-lookup"
+    headers = _auth_headers(token) if token else _anon_headers()
+    _debug_request("GET", url, headers, {"did": did})
+    resp = httpx.get(url, params={"did": did}, headers=headers, timeout=15)
+    _debug_response(resp)
+    data = resp.json()
+    if resp.status_code >= 400:
+        raise RuntimeError(data.get("error", f"HTTP {resp.status_code}"))
+    return data
+
+
+def search_phonebook(
+    query: str | None = None,
+    agent_type: str | None = None,
+    limit: int = 20,
+    token: str | None = None,
+) -> dict[str, Any]:
+    params: dict[str, str] = {"limit": str(limit)}
+    if query:
+        params["q"] = query
+    if agent_type:
+        params["type"] = agent_type
+    url = f"{_base_url()}/agent-lookup"
+    headers = _auth_headers(token) if token else _anon_headers()
+    _debug_request("GET", url, headers, params)
+    resp = httpx.get(url, params=params, headers=headers, timeout=15)
+    _debug_response(resp)
+    data = resp.json()
+    if resp.status_code >= 400:
+        raise RuntimeError(data.get("error", f"HTTP {resp.status_code}"))
+    return data
+
+
+def list_conversations(
+    token: str,
+    limit: int = 50,
+    with_did: str | None = None,
+    filter: str | None = None,
+) -> dict[str, Any]:
+    params: dict[str, str] = {"limit": str(limit)}
+    if with_did:
+        params["with"] = with_did
+    if filter:
+        params["filter"] = filter
+    url = f"{_base_url()}/conversations-list"
+    headers = _auth_headers(token)
+    _debug_request("GET", url, headers, params)
+    resp = httpx.get(url, params=params, headers=headers, timeout=15)
+    _debug_response(resp)
+    data = resp.json()
+    if resp.status_code >= 400:
+        raise RuntimeError(data.get("error", f"HTTP {resp.status_code}"))
+    return data
+
+
+def send_message(
+    token: str,
+    sender_did: str,
+    recipient_did: str,
+    message: dict[str, Any],
+    interaction_id: str | None = None,
+    on_behalf_of: str | None = None,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "sender_did": sender_did,
+        "recipient_did": recipient_did,
+        "message": message,
+    }
+    if interaction_id:
+        payload["interaction_id"] = interaction_id
+    if on_behalf_of:
+        payload["on_behalf_of"] = on_behalf_of
+    url = f"{_base_url()}/interactions-upsert"
+    headers = _auth_headers(token)
+    _debug_request("POST", url, headers, payload)
+    resp = httpx.post(url, headers=headers, json=payload, timeout=15)
+    _debug_response(resp)
+    data = resp.json()
+    if resp.status_code >= 400:
+        raise RuntimeError(data.get("error", f"HTTP {resp.status_code}"))
+    return data

b2alpha-0.4.0/b2alpha/auth.py

@@ -0,0 +1,216 @@
+"""Google OAuth authentication via Supabase."""
+
+from __future__ import annotations
+
+import http.server
+import json
+import threading
+import urllib.parse
+import webbrowser
+from typing import Any
+
+from .config import AUTH_FILE, load_env_config, save_json
+
+
+def _find_free_port() -> int:
+    import socket
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+# HTML returned to the browser after OAuth completes
+_SUCCESS_HTML = """<!DOCTYPE html>
+<html><head><title>B2Alpha</title>
+<style>body{font-family:system-ui;display:flex;justify-content:center;align-items:center;
+height:100vh;margin:0;background:#0a0a0a;color:#fff}
+.card{text-align:center;padding:2rem;border:1px solid #333;border-radius:12px;background:#111}
+h1{color:#22c55e}p{color:#aaa}</style></head>
+<body><div class="card"><h1>Logged in</h1>
+<p>You can close this tab and return to the terminal.</p></div></body></html>"""
+
+_ERROR_HTML = """<!DOCTYPE html>
+<html><head><title>B2Alpha</title>
+<style>body{font-family:system-ui;display:flex;justify-content:center;align-items:center;
+height:100vh;margin:0;background:#0a0a0a;color:#fff}
+.card{text-align:center;padding:2rem;border:1px solid #333;border-radius:12px;background:#111}
+h1{color:#ef4444}p{color:#aaa}</style></head>
+<body><div class="card"><h1>Login failed</h1>
+<p>%s</p><p>Please try again.</p></div></body></html>"""
+
+
+def login_google() -> dict[str, Any]:
+    """Run the full Google OAuth flow via Supabase and return the session dict."""
+    supabase_url, _anon_key = load_env_config()
+    port = 8914
+    redirect_uri = f"http://127.0.0.1:{port}/callback"
+
+    result: dict[str, Any] = {}
+    error_msg: str = ""
+    event = threading.Event()
+
+    class CallbackHandler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self) -> None:
+            nonlocal result, error_msg
+            parsed = urllib.parse.urlparse(self.path)
+
+            if parsed.path == "/callback":
+                # Supabase redirects with fragment (#access_token=...) which
+                # the browser keeps client-side. Serve a page that extracts it.
+                self.send_response(200)
+                self.send_header("Content-Type", "text/html")
+                self.end_headers()
+                self.wfile.write(b"""<!DOCTYPE html><html><body>
+<script>
+const hash = window.location.hash.substring(1);
+if (hash) {
+  fetch('/token?' + hash).then(() => {
+    document.body.innerHTML = '""" + _SUCCESS_HTML.encode().replace(b"'", b"\\'").replace(b"\n", b"") + b"""';
+  });
+} else {
+  const params = new URLSearchParams(window.location.search);
+  const err = params.get('error_description') || params.get('error') || 'unknown';
+  document.body.innerHTML = '<p>Error: ' + err + '</p>';
+  fetch('/token?error=' + encodeURIComponent(err));
+}
+</script><p>Processing...</p></body></html>""")
+                return
+
+            if parsed.path == "/token":
+                params = urllib.parse.parse_qs(parsed.query)
+                if "error" in params:
+                    error_msg = params["error"][0]
+                    self.send_response(200)
+                    self.send_header("Content-Type", "text/html")
+                    self.end_headers()
+                    self.wfile.write((_ERROR_HTML % error_msg).encode())
+                elif "access_token" in params:
+                    result = {
+                        "access_token": params["access_token"][0],
+                        "refresh_token": params.get("refresh_token", [""])[0],
+                        "expires_in": params.get("expires_in", ["3600"])[0],
+                        "token_type": params.get("token_type", ["bearer"])[0],
+                    }
+                    self.send_response(200)
+                    self.send_header("Content-Type", "text/plain")
+                    self.end_headers()
+                    self.wfile.write(b"ok")
+                else:
+                    error_msg = "no_token_received"
+                    self.send_response(400)
+                    self.end_headers()
+                    self.wfile.write(b"no token")
+                event.set()
+                return
+
+            self.send_response(404)
+            self.end_headers()
+
+        def log_message(self, format: str, *args: Any) -> None:
+            pass  # Silence HTTP logs
+
+    server = http.server.HTTPServer(("127.0.0.1", port), CallbackHandler)
+    thread = threading.Thread(target=server.handle_request)  # handle 2 requests (callback + token)
+    thread.daemon = True
+    thread.start()
+
+    # Build Supabase OAuth URL
+    oauth_url = (
+        f"{supabase_url}/auth/v1/authorize"
+        f"?provider=google"
+        f"&redirect_to={urllib.parse.quote(redirect_uri)}"
+    )
+
+    print(f"Opening browser for Google sign-in...")
+    print(f"If the browser doesn't open, visit:\n  {oauth_url}\n")
+    webbrowser.open(oauth_url)
+
+    # Wait for the callback, then handle the second /token request
+    server.handle_request()
+    event.wait(timeout=120)
+    server.server_close()
+
+    if error_msg:
+        raise RuntimeError(f"OAuth failed: {error_msg}")
+    if not result:
+        raise RuntimeError("OAuth timed out – no token received.")
+
+    save_json(AUTH_FILE, result)
+    return result
+
+
+def refresh_session() -> dict[str, Any] | None:
+    """Attempt to refresh the access token using the stored refresh token."""
+    import httpx
+
+    from .config import load_json
+
+    auth = load_json(AUTH_FILE)
+    refresh_token = auth.get("refresh_token")
+    if not refresh_token:
+        return None
+
+    supabase_url, anon_key = load_env_config()
+    resp = httpx.post(
+        f"{supabase_url}/auth/v1/token?grant_type=refresh_token",
+        headers={"apikey": anon_key, "Content-Type": "application/json"},
+        json={"refresh_token": refresh_token},
+    )
+    if resp.status_code != 200:
+        return None
+
+    data = resp.json()
+    session = {
+        "access_token": data["access_token"],
+        "refresh_token": data.get("refresh_token", refresh_token),
+        "expires_in": data.get("expires_in", 3600),
+        "token_type": "bearer",
+    }
+    save_json(AUTH_FILE, session)
+    return session
+
+
+def _decode_jwt_payload(token: str) -> dict:
+    """Decode the payload of a JWT without verification."""
+    import base64
+
+    payload_b64 = token.split(".")[1]
+    padding = 4 - len(payload_b64) % 4
+    if padding != 4:
+        payload_b64 += "=" * padding
+    return json.loads(base64.urlsafe_b64decode(payload_b64))
+
+
+def get_user_id(token: str) -> str:
+    """Extract the Supabase user ID (sub claim) from an access token."""
+    payload = _decode_jwt_payload(token)
+    uid = payload.get("sub")
+    if not uid:
+        raise RuntimeError("Token has no 'sub' claim.")
+    return uid
+
+
+def _is_token_expired(token: str) -> bool:
+    """Check if a JWT access token is expired (with 30s margin)."""
+    import time
+
+    try:
+        payload = _decode_jwt_payload(token)
+        exp = payload.get("exp", 0)
+        return time.time() > (exp - 30)
+    except Exception:
+        return True  # If we can't decode, treat as expired
+
+
+def get_valid_token() -> str:
+    """Return a valid access token, refreshing if needed."""
+    from .config import get_access_token
+
+    token = get_access_token()
+    if token and not _is_token_expired(token):
+        return token
+    session = refresh_session()
+    if session:
+        return session["access_token"]
+    raise RuntimeError("Not logged in. Run 'b2a login' first.")

b2alpha-0.4.0/b2alpha/bridge/__init__.py

@@ -0,0 +1,15 @@
+"""Intent-to-REST bridge scaffolding for company agent proxies."""
+
+from .adapter import RESTIntentAdapter
+from .proxy import CompanyAgentProxy
+from .registry import AdapterRegistry
+from .types import AdapterCall, AdapterResult, B2AIntent
+
+__all__ = [
+    "AdapterCall",
+    "AdapterRegistry",
+    "AdapterResult",
+    "B2AIntent",
+    "CompanyAgentProxy",
+    "RESTIntentAdapter",
+]

b2alpha-0.4.0/b2alpha/bridge/adapter.py

@@ -0,0 +1,72 @@
+"""Adapter interface + REST execution base."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Iterable
+
+import httpx
+
+from .types import AdapterCall, AdapterResult, B2AIntent
+
+
+class RESTIntentAdapter(ABC):
+    """Translates B2A intents to REST calls and normalizes responses."""
+
+    name: str = "adapter"
+    intent_patterns: tuple[str, ...] = ()
+
+    def can_handle(self, intent: str) -> bool:
+        for pattern in self.intent_patterns:
+            if pattern.endswith(".*") and intent.startswith(pattern[:-1]):
+                return True
+            if intent == pattern:
+                return True
+        return False
+
+    @abstractmethod
+    def build_call(self, intent: B2AIntent) -> AdapterCall:
+        """Convert a B2A intent into an HTTP request definition."""
+
+    def normalize_response(self, response: httpx.Response) -> Any:
+        """Return JSON when available, otherwise raw text."""
+        try:
+            return response.json()
+        except Exception:
+            return {"text": response.text}
+
+    def execute(
+        self,
+        intent: B2AIntent,
+        *,
+        base_url: str,
+        shared_headers: dict[str, str] | None = None,
+    ) -> AdapterResult:
+        call = self.build_call(intent)
+        headers: dict[str, str] = dict(shared_headers or {})
+        headers.update(call.headers)
+        url = f"{base_url.rstrip('/')}/{call.path.lstrip('/')}"
+
+        response = httpx.request(
+            call.method,
+            url,
+            params=call.query,
+            headers=headers,
+            json=call.json_body,
+            timeout=call.timeout_s,
+        )
+        data = self.normalize_response(response)
+        return AdapterResult(
+            status_code=response.status_code,
+            ok=response.status_code < 400,
+            data=data,
+            adapter=self.name,
+        )
+
+
+def list_supported_intents(adapters: Iterable[RESTIntentAdapter]) -> list[str]:
+    patterns: list[str] = []
+    for adapter in adapters:
+        patterns.extend(adapter.intent_patterns)
+    return sorted(set(patterns))
+

b2alpha-0.4.0/b2alpha/bridge/adapters/__init__.py

@@ -0,0 +1,5 @@
+"""Built-in adapter examples."""
+
+from .acme_orders import AcmeOrdersAdapter
+
+__all__ = ["AcmeOrdersAdapter"]