agentconnect-cli 0.1.0a1__py3-none-any.whl

agentconnect/tasks.py

@@ -0,0 +1,35 @@
+"""Stopping helper tasks without swallowing the caller's own cancellation.
+
+``task.cancel(); with suppress(CancelledError): await task`` is wrong: if
+the *calling* task is cancelled while it waits, its ``CancelledError`` is
+suppressed too, and the caller carries on as if nothing happened (so
+``Engine.stop`` or a shutdown that cancels a worker never takes effect).
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+
+async def cancel_and_wait(
+    *tasks: asyncio.Future[Any], ignore: tuple[type[BaseException], ...] = ()
+) -> None:
+    """Cancel ``tasks`` and wait until every one has finished.
+
+    How a task ended is ignored when it is its own cancellation or an
+    exception in ``ignore``; any other exception is raised (the first, in
+    argument order). If the calling task is cancelled meanwhile, its
+    ``CancelledError`` propagates: ``gather`` passes the caller's
+    cancellation on and reports the tasks' own as results.
+
+    The calling task itself, if it is among ``tasks``, is skipped: a task
+    can't wait for its own end, and gathering on itself would never return."""
+    current = asyncio.current_task()
+    tasks = tuple(t for t in tasks if t is not current)
+    for t in tasks:
+        t.cancel()
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+    for r in results:
+        if isinstance(r, BaseException) and not isinstance(r, (asyncio.CancelledError, *ignore)):
+            raise r

agentconnect/tokens.py

@@ -0,0 +1,63 @@
+"""The local API's bearer tokens and other 0600 secret files.
+
+``api-token`` (agent scope) and ``human-token`` (human scope) live in the
+data directory, created on first start. The runtime reads each once and
+keeps only its SHA-256 (:class:`TokenDigest`), so the token's value is not
+held in the runtime's memory (ADR-005, Decision 4). The CLI reads the file
+per command; the SDK and agent integrations read ``api-token`` only.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import os
+import secrets
+from pathlib import Path
+from typing import override
+
+from agentconnect.keystore import write_private
+
+API_TOKEN_FILE = "api-token"  # noqa: S105 - a file name
+HUMAN_TOKEN_FILE = "human-token"  # noqa: S105 - a file name
+
+
+def load_token(path: Path) -> str:
+    """Read the token at ``path``, creating it (0600) if missing. An existing
+    token file must be ours and private (no group or other bits)."""
+    if path.exists():
+        st = path.stat()
+        if st.st_mode & 0o077 or st.st_uid != os.geteuid():
+            msg = f"{path.name} must be owned by this user with mode 0600"
+            raise PermissionError(msg)
+        return path.read_text(encoding="ascii").strip()
+    token = secrets.token_urlsafe(32)
+    write_private(path, token.encode("ascii"))
+    return token
+
+
+class TokenDigest:
+    """The SHA-256 of a token, for a constant-time bearer check. The token's
+    value is never stored, and the digest is kept out of ``repr``."""
+
+    __slots__ = ("_digest",)
+
+    # SHA-256, not a password hash, on purpose: the tokens are 256 bits from
+    # secrets.token_urlsafe(32), not passwords people choose, so there is
+    # nothing to brute-force and no stretching (bcrypt, scrypt) to add. The
+    # hash only keeps the value out of memory; compare_digest keeps the
+    # comparison constant-time.
+    def __init__(self, token: str) -> None:
+        self._digest = hashlib.sha256(token.encode()).digest()
+
+    @classmethod
+    def of_file(cls, path: Path) -> TokenDigest:
+        """Load (or create) the token file at ``path`` and keep its digest."""
+        return cls(load_token(path))
+
+    def matches(self, bearer_token: str) -> bool:
+        return hmac.compare_digest(hashlib.sha256(bearer_token.encode()).digest(), self._digest)
+
+    @override
+    def __repr__(self) -> str:
+        return "TokenDigest(<redacted>)"

agentconnect/webhook.py

@@ -0,0 +1,199 @@
+"""The webhook adapter: POST every message and event to a callback URL.
+
+Delivery is **at least once**:
+
+* Messages go through the daemon's delivery loop, which keeps them in order
+  and in its durable inbound queue until :meth:`WebhookAdapter.deliver`
+  returns ``ACK``. A 2xx response is an ack; any other response, a timeout
+  or a connection error is ``RETRY``, and the daemon retries with
+  exponential backoff on its clock. Nothing later is delivered before it.
+* Events (``member_joined``, ``epoch_changed``, ``loop_guard``, ...) are
+  posted at once. If that fails, they wait in a bounded in-memory queue with
+  the same retry rule, and ``on_event`` raises, so the daemon keeps the event
+  unnotified and sends it again after a reconnect or restart (ADR-004). The
+  repeat carries the same ``event_id``.
+
+A receiver can therefore see a payload twice (the ack was lost) and must
+treat ``msg_id`` / ``event_id`` as idempotency keys. The Python SDK does.
+
+Every request is signed: ``X-AgentConnect-Signature: v0=<hex>`` is
+HMAC-SHA256 over ``<timestamp>.<body>`` with the adapter's secret, and
+``X-AgentConnect-Timestamp`` is the Unix time in seconds. Each attempt is
+signed afresh, so a captured request stops verifying after the receiver's
+skew window (5 minutes in the SDK).
+
+The callback is loopback unless the config opts in (``webhook.allow_remote``)
+and then it must be ``https``; redirects are never followed.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import hmac
+from collections import deque
+from typing import Any, override
+from urllib.parse import urlsplit
+
+import httpx
+
+from agentconnect import log
+from agentconnect.adapter import (
+    Capabilities,
+    Delivery,
+    DeliveryResult,
+    Event,
+    GroupView,
+    OutboundSend,
+    Sender,
+)
+from agentconnect.backoff import Backoff
+from agentconnect.clock import Clock, unix_seconds
+from agentconnect.payloads import encode, event_payload, message_payload
+from agentconnect.tasks import cancel_and_wait
+
+LOG = log.get("agentconnect.webhook")
+
+SIGNATURE_HEADER = "X-AgentConnect-Signature"
+TIMESTAMP_HEADER = "X-AgentConnect-Timestamp"
+SIGNATURE_VERSION = "v0"
+SECRET_FILE = "webhook-secret"  # noqa: S105 - a file name
+EVENT_QUEUE_LIMIT = 1000
+
+
+def sign(secret: str, timestamp: str, body: bytes) -> str:
+    """``v0=<hex>``: HMAC-SHA256 over ``<timestamp>.<body>``."""
+    mac = hmac.new(secret.encode(), timestamp.encode() + b"." + body, hashlib.sha256)
+    return f"{SIGNATURE_VERSION}={mac.hexdigest()}"
+
+
+class WebhookAdapter:
+    """Implements :class:`agentconnect.adapter.Adapter` over HTTP POST."""
+
+    name = "webhook"
+
+    def __init__(  # noqa: PLR0913
+        self,
+        url: str,
+        secret: str,
+        clock: Clock,
+        *,
+        transport: httpx.AsyncBaseTransport | None = None,
+        timeout: float = 10.0,
+        backoff: Backoff | None = None,
+    ) -> None:
+        self.url = url
+        self._secret = secret
+        self._clock = clock
+        self._transport, self._timeout = transport, timeout
+        self._client: httpx.AsyncClient | None = None
+        self._backoff = backoff or Backoff(base=1.0, cap=300.0)
+        self._events: deque[dict[str, Any]] = deque()
+        self._wake = asyncio.Event()
+        self._worker: asyncio.Task[None] | None = None
+        self._inflight = 0
+        self._quiet = asyncio.Event()
+        self._quiet.set()
+
+    @property
+    def _http(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                transport=self._transport,
+                timeout=self._timeout,
+                follow_redirects=False,
+                trust_env=False,
+            )
+        return self._client
+
+    @override
+    def __repr__(self) -> str:
+        host = urlsplit(self.url).netloc
+        return f"WebhookAdapter(host={host!r})"
+
+    def capabilities(self) -> Capabilities:
+        return Capabilities(accepts=["text", "data"], originates=False)
+
+    async def on_outbound(self, send: OutboundSend) -> None:
+        # Outbound messages go through the local API; start the event worker.
+        self._ensure_worker()
+
+    def _ensure_worker(self) -> None:
+        if self._worker is None or self._worker.done():
+            self._worker = asyncio.get_running_loop().create_task(self._run_events())
+
+    async def drain(self) -> None:
+        """Wait until no request is in flight (for orderly shutdown in tests)."""
+        await self._quiet.wait()
+
+    async def close(self) -> None:
+        try:
+            if self._worker is not None:
+                await cancel_and_wait(self._worker)
+                self._worker = None
+        finally:
+            if self._client is not None:
+                await self._client.aclose()
+                self._client = None
+
+    async def _post(self, payload: dict[str, Any]) -> bool:
+        body = encode(payload)
+        stamp = str(unix_seconds(self._clock))
+        headers = {
+            "content-type": "application/json",
+            TIMESTAMP_HEADER: stamp,
+            SIGNATURE_HEADER: sign(self._secret, stamp, body),
+        }
+        self._inflight += 1
+        self._quiet.clear()
+        try:
+            resp = await self._http.post(self.url, content=body, headers=headers)
+        except httpx.HTTPError as e:
+            LOG.warning("webhook_unreachable", error=type(e).__name__)
+            return False
+        finally:
+            self._inflight -= 1
+            if self._inflight == 0:
+                self._quiet.set()
+        if 200 <= resp.status_code < 300:  # noqa: PLR2004
+            return True
+        LOG.warning("webhook_rejected", status=resp.status_code)
+        return False
+
+    async def deliver(
+        self, group: GroupView, sender: Sender, to: list[str], inner: Delivery
+    ) -> DeliveryResult:
+        ok = await self._post(message_payload(group, inner))
+        return DeliveryResult.ACK if ok else DeliveryResult.RETRY
+
+    async def on_event(self, group: GroupView | None, event: Event) -> None:
+        """Send the event now when nothing is waiting ahead of it. If that
+        fails, or earlier events are still queued (order), queue it for the
+        retry worker and raise: the daemon then keeps the event unnotified
+        and sends it again after a reconnect or restart. The receiver dedupes
+        by ``event_id``, so the repeat is harmless."""
+        payload = event_payload(group, event)
+        if not self._events and await self._post(payload):
+            return
+        if all(p["event_id"] != event.event_id for p in self._events):
+            if len(self._events) >= EVENT_QUEUE_LIMIT:
+                self._events.popleft()
+                LOG.warning("webhook_event_dropped")
+            self._events.append(payload)
+        self._wake.set()
+        self._ensure_worker()
+        msg = "webhook not reachable"
+        raise ConnectionError(msg)
+
+    async def _run_events(self) -> None:
+        while True:
+            self._wake.clear()
+            while self._events:
+                head = self._events[0]
+                if await self._post(head):
+                    if self._events and self._events[0] is head:
+                        self._events.popleft()
+                    self._backoff.reset()
+                else:
+                    await self._clock.sleep(self._backoff.next())
+            await self._wake.wait()

agentconnect_cli-0.1.0a1.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: agentconnect-cli
+Version: 0.1.0a1
+Summary: AgentConnect daemon (agentconnectd) and CLI
+License-Expression: Apache-2.0
+Requires-Dist: a2a-sdk[http-server,signing]>=1.2.2
+Requires-Dist: agentconnect-core==0.1.0a1
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: keyring>=25.7.0
+Requires-Dist: mcp>=2.3.0
+Requires-Dist: pyjwt[crypto]>=2.15.1
+Requires-Dist: structlog>=26.1.0
+Requires-Dist: typer>=0.27.3
+Requires-Dist: uvicorn>=0.54.0
+Requires-Dist: websockets>=17.2
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# agentconnect-cli
+
+The AgentConnect daemon (`agentconnectd`) and CLI (`agentconnect`). The
+distribution is `agentconnect-cli`; the command and the import package are
+`agentconnect`. See the repository [README](https://github.com/mbocevski/agent-connect/blob/v0.1.0a1/README.md) and
+[SPEC.md](https://github.com/mbocevski/agent-connect/blob/v0.1.0a1/SPEC.md).
+
+```sh
+agentconnect daemon run [--config PATH] [--tcp-port N]   # foreground, JSON logs on stderr
+agentconnect status [--json]                             # reads the local API
+```
+
+Everything protocol-related is in the runtime, `agentconnect.runtime`
+(`Runtime`, with its engine, local API, adapters and agent-scope
+`AgentApi`). `agentconnectd` (`agentconnect.daemon`) is one host of it; the
+Python SDK's embedded mode (`AgentConnect.embedded`, [docs/sdk.md](https://github.com/mbocevski/agent-connect/blob/v0.1.0a1/docs/sdk.md))
+is the other. Both run the same checks, and both serve the local API below.
+
+The invite lifecycle (`group`, `invite`, `accept`, `groups`, `approvals`,
+`verify`, `leave`, `send`, `events`) is documented in
+[docs/cli.md](https://github.com/mbocevski/agent-connect/blob/v0.1.0a1/docs/cli.md), with the `--json` schemas and exit codes.
+`approvals approve`, `approvals reject` and `verify` use the human token:
+**never give an agent the human token or let it run those commands for the
+human.**
+
+Don't give agents shell or file access to the data directory either: an
+agent that can read it can approve joins and mark codes verified as you,
+because the human token is a file there. Agents that need a shell can run
+as another OS user, with the daemon under a user of its own
+([docs/isolation.md](https://github.com/mbocevski/agent-connect/blob/v0.1.0a1/docs/isolation.md)).
+
+## What the daemon holds
+
+- One identity and one instance, created on first start, in the OS keyring
+  when one is usable and otherwise in 0600 key files (`keystore = "auto" |
+  "keyring" | "file"`).
+- The core's MLS state in `mls.sqlite3`, a SQLCipher database encrypted
+  under a `db_key` from the same keystore.
+- Its own `daemon.sqlite3`: groups, members (with the local *verified*
+  flag), Agent Cards, out-of-sync flags, and the durable outbox and inbox.
+  It is a SQLCipher database too, under a key the core derives from
+  `db_key` (ADR-003). Plaintext stays only while it is needed: an outbox
+  row keeps only its ids once the relay has answered it, and an inbox row
+  drops its message once the adapter has accepted it.
+
+The data directory (`~/.local/share/agentconnect`) is 0700 and every file in
+it 0600. Configuration is `~/.config/agentconnect/config.toml`; see
+[docs/config.md](https://github.com/mbocevski/agent-connect/blob/v0.1.0a1/docs/config.md) for the keys and the `AC_*` overrides.
+
+## Local control API
+
+JSON over HTTP/1.1 on a Unix socket in the data directory, or on
+`127.0.0.1:<port>`. Every request needs `Authorization: Bearer <token>`.
+[docs/api.md](https://github.com/mbocevski/agent-connect/blob/v0.1.0a1/docs/api.md) describes the transport, tokens, errors and
+every route with its request and response shapes.
+
+Two tokens live in the data directory: `api-token` (agent scope) and
+`human-token` (human scope, also accepted for everything else). Approving a
+join and marking a member verified are human decisions (SPEC §6.2, §11): an
+agent that could approve its own joins, or mark the short code as compared,
+would remove exactly the checks that catch a leaked link or a relay in the
+middle. Give agent tooling only `api-token`. Both files belong to the same OS
+user, so the split keeps the human capability out of agent integrations by
+default; it is not a sandbox.
+
+Invite secrets never leave the daemon: the URL is returned to the caller and
+the relay only receives the public invite metadata.
+
+## Adapters
+
+`agentconnect.adapter.Adapter` is the interface for agent integrations:
+`deliver(group, sender, to, inner) -> ack | retry`, `on_event(group, event)`,
+`on_outbound(send)` and `capabilities()`. Every delivery carries the SPEC
+§10.1 untrusted framing. A relay frame is acknowledged only after the core
+processed it and the adapter accepted the resulting delivery.
+
+Delivery is **at least once**: after a crash, `deliver` and `on_event` may
+repeat a message or an event. Every delivery has a stable `msg_id` and every
+event a stable `event_id`; deduplicate by them. Nothing is lost: an event is
+recorded before the adapter hears of it and sent again on restart until
+`on_event` returns (ADR-004).
+The webhook adapter ([docs/adapters/webhook.md](https://github.com/mbocevski/agent-connect/blob/v0.1.0a1/docs/adapters/webhook.md)) and the SSE adapter (`GET /v0/events`, [docs/api.md](https://github.com/mbocevski/agent-connect/blob/v0.1.0a1/docs/api.md#event-stream)) serve headless agents.
+`CallbackAdapter` (`agentconnect.callback`) is the embedded SDK's in-process adapter, with the webhook's retry rules. `RecordingAdapter` is the in-memory adapter used by tests. Every message in
+and out goes through the safety policy (`agentconnect.policy`) before any
+adapter sees it ([docs/safety.md](https://github.com/mbocevski/agent-connect/blob/v0.1.0a1/docs/safety.md)).

agentconnect_cli-0.1.0a1.dist-info/RECORD

@@ -0,0 +1,64 @@
+agentconnect/__init__.py,sha256=bsDXOpok9J8_HaxKa8g2w5Horjj3pO3C3CHypha20rE,60
+agentconnect/a2a_adapter/__init__.py,sha256=xkEkmb6Kh7t0rSUkdt6Y57ki6M6awjZqTd7--Y7EA8M,249
+agentconnect/a2a_adapter/adapter.py,sha256=tMQHp_UpXUwaUMNYgWQ_H9OYZBFUPS8CVoWoEpKzR7M,24019
+agentconnect/a2a_adapter/cards.py,sha256=D49D0B3M0LPErmI-fAh8hh7xnxKvoswNeb0M_g0Zf3Y,5291
+agentconnect/a2a_adapter/convert.py,sha256=A6POHwZXlAlbdojXcWHmcgGfq79KxnJlxQ4O1we6Ijo,5470
+agentconnect/a2a_adapter/facade.py,sha256=921kpYNFhpZQV9F51guGNLy-gp-O2xEkgUpGzRlOdao,23155
+agentconnect/a2a_adapter/seen.py,sha256=YDOwFVbPTGjrojcDQbMS52VkZGcNDPdhX83g1ET35_Q,1680
+agentconnect/a2a_adapter/serve.py,sha256=U9HXGItnEqPbTvDw90Lc62fKNAUj0Dm2KtM6A49zNbU,2164
+agentconnect/adapter.py,sha256=mjDQc5WRqB_Yb_ZI31L96AzDEG3fU2Oo3ew18KVijeo,11043
+agentconnect/adapters.py,sha256=WnIZ_QoeRT5pysFpY7ukX1QV3PHotbU8zftEGofng_M,2425
+agentconnect/apiclient.py,sha256=nNpwBpkj2WovWz51XDRCRg92Zmpov3-f9j3JE89enuY,2059
+agentconnect/backoff.py,sha256=hmBRJyMegRmNrlGNJLFE6fASVcuaDPYF3DV759bLaqo,1358
+agentconnect/callback.py,sha256=4OW64hpeIA9pZNQ7Sm6b5usqsNE66Gv24Uf-uIAMTcY,13224
+agentconnect/cli.py,sha256=lj8Jcr2JX95dXN-pyxQ2OTAogQ8fAOHE6pQPLc2PPmQ,95692
+agentconnect/cli_json.py,sha256=l0O9_ffTXw-V7RERAHlA9-i-cZGNub8VG2Mu7R8jiHA,15950
+agentconnect/cli_support.py,sha256=SW8xzdXht2rOPe5B_LsLewmaL4xTnVq077_XlCkYjY8,16936
+agentconnect/clock.py,sha256=oXLBoyrD67daCGt-8i0kLPeGN1q_KG5ORA3mE-SVXCI,5631
+agentconnect/config.py,sha256=2JLWf-7TUQMbSe41MCPNVjXcV7d8oiClMAMTibSnAMw,51265
+agentconnect/daemon/__init__.py,sha256=vJk7Nc3pdvFPAeiF_PeWwpy2elGxLOEznicVBN5B_3s,1456
+agentconnect/deliveries.py,sha256=lK9nMSszUZflsHu6uFIly_jnjVAEKwT_-u66XzC7DLI,12106
+agentconnect/directory_client.py,sha256=C_PvVCYHUP7Z12t8A79sKvaSRI7VKOINCLV_GYcYY-M,10031
+agentconnect/failpoints.py,sha256=GcCNIuF0-95uMdbjhswAbtEWme3o0CWK3WYtdP7XH5g,4496
+agentconnect/identity.py,sha256=YxKeG8HTmMKK_0VkXfXnssKdjU-93EE0ia8_04nnP_U,3883
+agentconnect/isolation.py,sha256=8glVNZxHMPbZ-oAsFceFjKwEjH2C6m4u3cx851JEADA,13406
+agentconnect/keystore.py,sha256=wtxjMr3j5kpqpwJyqoe0GRUOiw0qecoaLSLIzKqexrE,9525
+agentconnect/limits.py,sha256=aBRJpjA9JoJvi7eG87tJvSK9OUAtpGjAA20FKFFgOLA,18787
+agentconnect/log.py,sha256=qgLeXr4lP5T43k4Tr4VYjBVplwrTzoX1rGL2Vp9DSc0,4144
+agentconnect/mcp/__init__.py,sha256=tFETWMpHa02lUm4folUmiV9QPWYb0TySN9xVysuvoik,854
+agentconnect/mcp/backend.py,sha256=qZkVRf9QOW0uTJ8ufJJhpYwBVIsnAmKu5ZTdHcoesII,15593
+agentconnect/mcp/server.py,sha256=L0RX5zUdvoYfOF47ufNMXZ-Hhj-80-JFBmS2bZbSBBA,14641
+agentconnect/mcp/session.py,sha256=XwBv7GiwFsNKY9qsRaXb5tsdDSq8VX7o24rNLtd5rbI,15902
+agentconnect/mcp/tools.py,sha256=duUEt1IXusgH1Wpu1XGvM8dZ_U1GDYCy5nWRe3JlFMs,21696
+agentconnect/ownerfile.py,sha256=v8L0wXcuTYg0xrrBvixXEfdOoHbG5poCm7EToyP7wMI,8520
+agentconnect/payloads.py,sha256=Nha7_yGQpQ1LTJBk0qwgTb75ZGYJ-zZm-YrV7Ycl4zE,3737
+agentconnect/policy.py,sha256=y0i3F_ZGRVKT7jhOUT0N2Bip9jCBH98XEJATTEEIDgk,41104
+agentconnect/provision.py,sha256=85hG9Sm5RQ3vfRq1kjRj7DPECXJ5evXACgtxJ6hz-Aw,10015
+agentconnect/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentconnect/relay.py,sha256=NHZ7BJbiwHI-ENz7tyJcydHXObBugEGwEPq5N5SD-KM,16524
+agentconnect/runtime/__init__.py,sha256=-R18y4c8GEI1jsMnCNwSlhtDEfmJg-O_O_EQKD4sRB0,1535
+agentconnect/runtime/agent.py,sha256=EpGX1GKXxF22x4mc8sPAx3tF6qTqxbzH71OY7B3UvJQ,10298
+agentconnect/runtime/api.py,sha256=ntQcuw4QbThHovlyTGW0PMiVuZuC1AVNK863rlxVUFY,89586
+agentconnect/runtime/engine.py,sha256=NMk1hUwFPZ_-yLJPpmS1kvYV69TTHVqhfusbHu2Mc6I,248443
+agentconnect/runtime/errors.py,sha256=28QEhRUh1NYriVWV_Z9Ic7KdQzOlsEXN_SmRI5ya18c,1412
+agentconnect/runtime/floor.py,sha256=kczLLji-8brEILTA3-4AYjfmd2RmoWFZ_nImXnM51QQ,30026
+agentconnect/runtime/groups.py,sha256=h47KUZHwSIeJpwnhtPQy9RwSRVYFnkyB-kO-sXmlBUs,63499
+agentconnect/runtime/knocks.py,sha256=-Cs6TAGskxXQ3iZcc2XW_RG3_MDW-16E4NObvP0U9Zo,63059
+agentconnect/runtime/ledger.py,sha256=2wGmTc4Ba893uWgYkBhAVYumGF6Ep426ukZV5dnHpgg,4002
+agentconnect/runtime/listing.py,sha256=dnfsfOQErWK4z3J1Hio1jzkZyGbwdU_cdfOSCM074yM,59261
+agentconnect/runtime/registry.py,sha256=pYjEFglau2syD8GLqcuXAYA8Ve0y1api7fI5Aydwf9E,1776
+agentconnect/runtime/runtime.py,sha256=0_7ppJ-RJTWjPxY3M13uWkSq_lzTlnMVb-9A8Gm7AZ4,6038
+agentconnect/runtime/sas.py,sha256=ZKNqklBmqWgiVnzhzr4OTgtJE40C4e1pyq1qOZDmbRg,43312
+agentconnect/sas_emoji.py,sha256=5DVw27KmRp81c-C_diteTzkH7t35OZTjAzMzh5xm4bc,2097
+agentconnect/schemas.py,sha256=glRv29sy62y12hliqR2MKsS7Tk0QYV5f-jpavhVo908,14195
+agentconnect/shapes.py,sha256=fHEwMWyxLBP2S4Y3QIokh-QblRXPUI8NmOfi27uth4s,1946
+agentconnect/sockets.py,sha256=Ia8p8cBn4ZwHwSnd5noD2ksr_FHRwd3bXm17kZDXtYc,3674
+agentconnect/sse.py,sha256=wdCnxFEY0VF_XvxvMuD-O0LiLls7Db-5ahr2f9gTeh8,8644
+agentconnect/store.py,sha256=hSTqOJ9bpOlofjMFrOjs-KB1ObotpBluwwbeHfGcgec,132319
+agentconnect/tasks.py,sha256=rKwA4AtBXWrxlMMKazuEdt51l_jZAeFAWjMBcxwOBBw,1458
+agentconnect/tokens.py,sha256=CFV3v1HjxBBzuO3U17xaC4DFrYE89nd5JngoYAabR48,2360
+agentconnect/webhook.py,sha256=jd_lvGPdlGecFwTDuU6HWhvHLgEd7v1v-3cInvbrcrE,7373
+agentconnect_cli-0.1.0a1.dist-info/WHEEL,sha256=1dD_GoEqEIxQ7VnrUExgdj_eExY4b4UgfR0iBlGKVac,80
+agentconnect_cli-0.1.0a1.dist-info/entry_points.txt,sha256=R0I5wTCDhHPFR4SWEr2j4uDfNXpJjC-CkqHVVPRliAI,55
+agentconnect_cli-0.1.0a1.dist-info/METADATA,sha256=ABcvhL4lNZyf4iKjmsLldaj4zDUYzGhArEL5nNHgVI0,5722
+agentconnect_cli-0.1.0a1.dist-info/RECORD,,

agentconnect_cli-0.1.0a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.4
+Root-Is-Purelib: true
+Tag: py3-none-any

agentconnect_cli-0.1.0a1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+agentconnect = agentconnect.cli:app
+