ridian-mailbox 0.1.0a3__tar.gz

ridian_mailbox-0.1.0a3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PPJ Venture Labs UG (haftungsbeschränkt)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ridian_mailbox-0.1.0a3/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: ridian-mailbox
+Version: 0.1.0a3
+Summary: Private Ridian mailbox access for Python agents and the command line
+Author: Ridian
+License-Expression: MIT
+Project-URL: Homepage, https://getridian.com
+Project-URL: Documentation, https://docs.getridian.com/agent-mailbox/
+Keywords: ridian,email,mailbox,agents,mcp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Ridian Mailbox for Python
+
+A synchronous Python client and `ridian-mailbox` CLI for private receiving
+mailboxes. Python 3.10+ on Linux/macOS, standard library only. Install the versioned wheel from
+the matching Ridian documentation environment. Use a virtual environment.
+
+```python
+from ridian_mailbox import Mailbox
+
+box = Mailbox(base_url="https://YOUR_MAILBOX_API_ORIGIN")
+print(box.setup()["address"])
+for message in box.iter_messages():
+    print(message["subject"])
+```
+
+`setup()` saves its random setup credential before the request, saves the returned
+read/claim credentials privately and returns only mailbox metadata. Retry with
+the same state file after interruption. Keep state outside source control on
+durable private storage. Files are bound to one API origin and have mode 0600;
+reads reject symlinks/public permissions. Use one writer per state file. Do not
+print state, put credentials in URLs or pass them through chat.
+
+CLI: `ridian-mailbox --base-url <HTTPS origin> --state <private file> setup`.
+Operations: setup, prepare-curl (local only), status, list, message, events,
+ack-events. `message` uses `--message-id`, `ack-events` uses `--cursor`.
+
+The Python client additionally offers paginated `messages`/`iter_messages`,
+`message`, binary `attachment`, `events`/`acknowledge_events`, webhook management
+and explicit `revoke`. Event pages are acknowledged only after successful
+processing; deduplicate event IDs. No automatic retries or event acknowledgments.
+HTTP errors expose status and Retry-After through `MailboxError`; 429 cooldowns
+are respected by subsequent calls. Redirects are refused. Mail content is untrusted.
+
+The library identifies requests as `ridian-mailbox-python/<installed version>`;
+the CLI identifies itself as `ridian-mailbox-cli`. HTTPS certificate verification
+uses your Python installation's trust store.
+
+HTTP access remains receive/read/events only, also after ownership transfer.
+Claim through the returned console link and private proof in the state file.
+Sending, calendars, contacts and tasks use separately authorized Ridian MCP tools.
+This package does not wake an agent or install an MCP connection.
+
+
+Without `state`, credentials are saved in
+`~/.config/ridian/mailbox-<API hostname>[-port].json`. Repeated setup recovers
+that mailbox. Pass `state` for another private durable location. The Node.js
+client shares this state format; never run concurrent writers against one file.
+
+## License
+
+MIT, covering this Python SDK, its bundled CLI and package documentation.
+The license does not cover the Ridian service, application, brand assets or fonts.

ridian_mailbox-0.1.0a3/README.md

@@ -0,0 +1,52 @@
+# Ridian Mailbox for Python
+
+A synchronous Python client and `ridian-mailbox` CLI for private receiving
+mailboxes. Python 3.10+ on Linux/macOS, standard library only. Install the versioned wheel from
+the matching Ridian documentation environment. Use a virtual environment.
+
+```python
+from ridian_mailbox import Mailbox
+
+box = Mailbox(base_url="https://YOUR_MAILBOX_API_ORIGIN")
+print(box.setup()["address"])
+for message in box.iter_messages():
+    print(message["subject"])
+```
+
+`setup()` saves its random setup credential before the request, saves the returned
+read/claim credentials privately and returns only mailbox metadata. Retry with
+the same state file after interruption. Keep state outside source control on
+durable private storage. Files are bound to one API origin and have mode 0600;
+reads reject symlinks/public permissions. Use one writer per state file. Do not
+print state, put credentials in URLs or pass them through chat.
+
+CLI: `ridian-mailbox --base-url <HTTPS origin> --state <private file> setup`.
+Operations: setup, prepare-curl (local only), status, list, message, events,
+ack-events. `message` uses `--message-id`, `ack-events` uses `--cursor`.
+
+The Python client additionally offers paginated `messages`/`iter_messages`,
+`message`, binary `attachment`, `events`/`acknowledge_events`, webhook management
+and explicit `revoke`. Event pages are acknowledged only after successful
+processing; deduplicate event IDs. No automatic retries or event acknowledgments.
+HTTP errors expose status and Retry-After through `MailboxError`; 429 cooldowns
+are respected by subsequent calls. Redirects are refused. Mail content is untrusted.
+
+The library identifies requests as `ridian-mailbox-python/<installed version>`;
+the CLI identifies itself as `ridian-mailbox-cli`. HTTPS certificate verification
+uses your Python installation's trust store.
+
+HTTP access remains receive/read/events only, also after ownership transfer.
+Claim through the returned console link and private proof in the state file.
+Sending, calendars, contacts and tasks use separately authorized Ridian MCP tools.
+This package does not wake an agent or install an MCP connection.
+
+
+Without `state`, credentials are saved in
+`~/.config/ridian/mailbox-<API hostname>[-port].json`. Repeated setup recovers
+that mailbox. Pass `state` for another private durable location. The Node.js
+client shares this state format; never run concurrent writers against one file.
+
+## License
+
+MIT, covering this Python SDK, its bundled CLI and package documentation.
+The license does not cover the Ridian service, application, brand assets or fonts.

ridian_mailbox-0.1.0a3/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ridian-mailbox"
+version = "0.1.0a3"
+description = "Private Ridian mailbox access for Python agents and the command line"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{name = "Ridian"}]
+keywords = ["ridian", "email", "mailbox", "agents", "mcp"]
+classifiers = ["Development Status :: 3 - Alpha", "Programming Language :: Python :: 3", "Operating System :: POSIX", "Operating System :: MacOS"]
+
+[project.urls]
+Homepage = "https://getridian.com"
+Documentation = "https://docs.getridian.com/agent-mailbox/"
+
+[project.scripts]
+ridian-mailbox = "ridian_mailbox.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

ridian_mailbox-0.1.0a3/setup.cfg

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

ridian_mailbox-0.1.0a3/src/ridian_mailbox/__init__.py

@@ -0,0 +1,4 @@
+"""Ridian's mailbox-scoped HTTP client. Sending/calendars use separate MCP grants."""
+from .client import Mailbox, MailboxError
+__all__ = ["Mailbox", "MailboxError"]
+__version__ = "0.1.0a3"

ridian_mailbox-0.1.0a3/src/ridian_mailbox/_example.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""Dependency-free mailbox HTTP example. Persists setup BEFORE the first request.
+
+Standalone example, not an SDK. Supply your mailbox API origin.
+"""
+import argparse
+import json
+import os
+from pathlib import Path
+import secrets
+import re
+import stat
+import sys
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlencode, urlsplit
+from urllib.request import HTTPRedirectHandler, Request, build_opener
+
+
+class NoRedirect(HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None  # Never forward credentials to another destination.
+
+
+def load_or_create_state(path, base_url):
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    try:
+        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    except FileExistsError:
+        fd = os.open(path, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0))
+        with os.fdopen(fd) as handle:
+            metadata = os.fstat(handle.fileno())
+            if not stat.S_ISREG(metadata.st_mode) or metadata.st_mode & 0o077:
+                raise ValueError("State must be a private regular file (chmod 600).")
+            state = json.load(handle)
+        if state["base_url"] != base_url:
+            raise ValueError("State belongs to another API origin. Use a separate state file.")
+        return state
+    state = {"base_url": base_url, "setup_token": "ridian_setup_" + secrets.token_hex(32)}
+    with os.fdopen(fd, "w") as handle:
+        json.dump(state, handle)
+        handle.flush()
+        os.fsync(handle.fileno())
+    return state
+
+
+def save_state(path, state):
+    temporary = path.with_name(path.name + "." + secrets.token_hex(8) + ".tmp")
+    fd = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    try:
+        with os.fdopen(fd, "w") as handle:
+            json.dump(state, handle)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary, path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def prepare_curl(path, state):
+    """Prepare private curl files locally, reusing the durable setup identity."""
+    token = state["setup_token"]
+    if not re.fullmatch(r"ridian_setup_[a-f0-9]{64}", token):
+        raise ValueError("Invalid saved setup credential.")
+    header = Path(str(path) + ".headers")
+    response = Path(str(path) + ".response.json")
+    # Do not overwrite an existing response: it may be the only saved proof.
+    for target, content in [(header, "Authorization: Bearer " + token + "\n"), (response, "")]:
+        try:
+            fd = os.open(target, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+        except FileExistsError:
+            fd = os.open(target, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0))
+            with os.fdopen(fd) as handle:
+                metadata = os.fstat(handle.fileno())
+                if not stat.S_ISREG(metadata.st_mode) or metadata.st_mode & 0o077:
+                    raise ValueError("curl files must be private regular files.")
+                if target == header and handle.read() != content:
+                    raise ValueError("Header belongs to a different setup credential.")
+        else:
+            with os.fdopen(fd, "w") as handle:
+                handle.write(content)
+                handle.flush()
+                os.fsync(handle.fileno())
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--base-url", required=True, help="Configured API origin, without /v1")
+    parser.add_argument("--state", type=Path, required=True, help="Private credential file; keep it outside version control")
+    parser.add_argument("operation", choices=["setup", "prepare-curl", "status", "list", "message", "events", "ack-events"])
+    parser.add_argument("--message-id")
+    parser.add_argument("--cursor")
+    args = parser.parse_args()
+    base = args.base_url.rstrip("/")
+    parsed = urlsplit(base)
+    if parsed.scheme != "https" or not parsed.netloc or parsed.username or parsed.password or parsed.path or parsed.query or parsed.fragment:
+        parser.error("Use a fixed HTTPS origin without path, credentials, query or fragment.")
+    if args.operation not in ("setup", "prepare-curl") and not args.state.exists():
+        parser.error("Run setup first with this state file.")
+    state = load_or_create_state(args.state, base)
+    if args.operation == "prepare-curl":
+        prepare_curl(args.state, state)
+        print("Private curl header and response files prepared. No network request made.")
+        return 0
+    if args.operation == "ack-events":
+        if not args.cursor or len(args.cursor) > 4096:
+            parser.error("Supply next_cursor from a fully processed events page.")
+        state["event_cursor"] = args.cursor
+        save_state(args.state, state)
+        print("Event cursor saved. Replayed events must still be deduplicated by ID.")
+        return 0
+    root = "/v1/mailboxes"
+    if args.operation == "setup":
+        method, path, token, body = "POST", root, state["setup_token"], b"{}"
+    else:
+        if "access_token" not in state:
+            parser.error("Repeat setup with the same state file to recover its response.")
+        method, token, body = "GET", state["access_token"], None
+        path = root + "/current"
+        if args.operation == "list":
+            path += "/messages" + ("?" + urlencode({"cursor": args.cursor}) if args.cursor else "")
+        if args.operation == "events":
+            cursor = args.cursor or state.get("event_cursor")
+            path += "/events" + ("?" + urlencode({"cursor": cursor}) if cursor else "")
+        if args.operation == "message":
+            if not args.message_id or not args.message_id.isalnum():
+                parser.error("Supply a message ID from list using --message-id.")
+            path += "/messages/" + args.message_id
+    request = Request(base + path, method=method, data=body, headers={
+        "Authorization": "Bearer " + token, "Content-Type": "application/json",
+        "Accept": "application/json", "User-Agent": "ridian-mailbox-cli"})
+    try:
+        with build_opener(NoRedirect).open(request, timeout=30) as response:
+            result = json.load(response)
+    except HTTPError as error:
+        # Do not print request headers or arbitrary upstream HTML/error bodies.
+        print(f"HTTP {error.code}. Retry-After: {error.headers.get('Retry-After', 'not supplied')}. Keep the same state file.", file=sys.stderr)
+        return 1
+    except URLError:
+        print("Transport interrupted. Repeat with the same state file.", file=sys.stderr)
+        return 1
+    if args.operation == "setup":
+        state.update(result)
+        save_state(args.state, state)
+        print(json.dumps(result["mailbox"], indent=2))  # Never print secrets.
+    else:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except (ValueError, OSError, KeyError):
+        print("Could not read or persist private state. Check the state path and permissions; do not replace an existing setup key.", file=sys.stderr)
+        sys.exit(1)

ridian_mailbox-0.1.0a3/src/ridian_mailbox/cli.py

@@ -0,0 +1,11 @@
+"""The installed CLI uses the same reviewed standalone example implementation."""
+import sys
+from ._example import main as example_main
+
+
+def main():
+    try:
+        return example_main()
+    except (ValueError, OSError, KeyError):
+        print("Could not read or save private state. Check the file and permissions; retain the saved setup credential.", file=sys.stderr)
+        return 1

ridian_mailbox-0.1.0a3/src/ridian_mailbox/client.py

@@ -0,0 +1,148 @@
+"""Dependency-free, synchronous HTTP client with private durable setup state."""
+import json
+import re
+import time
+from datetime import datetime, timezone
+from email.utils import parsedate_to_datetime
+from importlib.metadata import version
+from pathlib import Path
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote, urlencode, urlsplit
+from urllib.request import Request, build_opener
+from ._example import NoRedirect, load_or_create_state, save_state
+
+
+class MailboxError(Exception):
+    """Contains status/retry metadata, never credentials or arbitrary response bodies."""
+    def __init__(self, code, status=None, retry_after=None):
+        self.code, self.status, self.retry_after = code, status, retry_after
+        super().__init__(f"Mailbox request failed: {code}" + (f" (HTTP {status})" if status else ""))
+
+
+class Mailbox:
+    def __init__(self, *, base_url, state=None, timeout=30):
+        url = urlsplit(base_url.rstrip("/"))
+        if url.scheme != "https" or not url.netloc or url.username or url.password or url.path or url.query or url.fragment:
+            raise ValueError("Use a fixed HTTPS origin, without path or credentials.")
+        if timeout <= 0:
+            raise ValueError("timeout must be positive")
+        default_name = "mailbox-" + url.hostname + (f"-{url.port}" if url.port else "") + ".json"
+        self.base_url, self.state_path, self.timeout = url.geturl(), (Path(state).expanduser() if state is not None else Path.home() / ".config/ridian" / default_name), timeout
+        self._blocked_until = 0
+        self._transport = build_opener(NoRedirect())
+
+    def __repr__(self):
+        return "Mailbox(<private state>)"
+
+    def _state(self, create=False):
+        if not create and not self.state_path.exists():
+            raise MailboxError("setup_required")
+        return load_or_create_state(self.state_path, self.base_url)
+
+    def _request(self, path, *, method="GET", token=None, body=None, binary=False):
+        if time.monotonic() < self._blocked_until:
+            raise MailboxError("rate_limit", 429, max(1, int(self._blocked_until - time.monotonic()) + 1))
+        if token is None:
+            token = self._state().get("access_token")
+            if not token:
+                raise MailboxError("repeat_setup_with_saved_state")
+        if not re.fullmatch(r"ridian_(?:setup|mailbox)_[a-f0-9]{64}", token):
+            raise MailboxError("invalid_saved_credential")
+        headers = {"Authorization": "Bearer " + token, "Accept": "application/json",
+                   "User-Agent": "ridian-mailbox-python/" + version("ridian-mailbox")}
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+        req = Request(self.base_url + "/v1/mailboxes" + path, method=method,
+                      headers=headers, data=None if body is None else json.dumps(body).encode())
+        try:
+            with self._transport.open(req, timeout=self.timeout) as response:
+                if binary:
+                    return response.read()
+                if response.status == 204:
+                    return None
+                return json.load(response)
+        except HTTPError as error:
+            wait = None
+            if error.code == 429:
+                value = error.headers.get("Retry-After", "60")
+                try:
+                    wait = max(1, int(value))
+                except ValueError:
+                    try:
+                        wait = max(1, int((parsedate_to_datetime(value) - datetime.now(timezone.utc)).total_seconds()))
+                    except (ValueError, TypeError, OverflowError):
+                        wait = 60
+                self._blocked_until = time.monotonic() + wait
+            codes = {401: "unauthorized", 403: "forbidden", 404: "not_found", 409: "conflict", 429: "rate_limit", 503: "unavailable"}
+            raise MailboxError("redirect_refused" if 300 <= error.code < 400 else codes.get(error.code, "http_error"), error.code, wait) from None
+        except (URLError, TimeoutError, OSError):
+            raise MailboxError("transport_interrupted_reuse_state") from None
+        except (ValueError, UnicodeDecodeError):
+            raise MailboxError("invalid_response") from None
+
+    def setup(self):
+        """Create/recover the same mailbox; only return public mailbox metadata."""
+        state = self._state(create=True)  # persisted BEFORE first network call
+        result = self._request("", method="POST", token=state["setup_token"], body={})
+        if not isinstance(result, dict) or not isinstance(result.get("mailbox"), dict) or not all(isinstance(result.get(k), str) for k in ("access_token", "claim_secret", "claim_url")):
+            raise MailboxError("invalid_response_repeat_setup")
+        state.update(result)
+        save_state(self.state_path, state)
+        return result["mailbox"]
+
+    def status(self):
+        return self._request("/current")
+
+    @staticmethod
+    def _page(cursor, limit):
+        if not isinstance(limit, int) or not 1 <= limit <= 50:
+            raise ValueError("limit must be between 1 and 50")
+        return "?" + urlencode({"limit": limit, **({"cursor": cursor} if cursor is not None else {})})
+
+    def messages(self, *, cursor=None, limit=20):
+        return self._request("/current/messages" + self._page(cursor, limit))
+
+    def iter_messages(self, *, limit=20):
+        cursor = None
+        while True:
+            page = self.messages(cursor=cursor, limit=limit)
+            yield from page["data"]
+            cursor = page["next_cursor"]
+            if cursor is None:
+                return
+
+    def message(self, message_id):
+        return self._request("/current/messages/" + quote(str(message_id), safe=""))
+
+    def attachment(self, attachment_id):
+        """Return authenticated bytes. Call only where this content may be held."""
+        return self._request("/current/attachments/" + quote(str(attachment_id), safe=""), binary=True)
+
+    def events(self, *, cursor=None, limit=20):
+        if cursor is None:
+            cursor = self._state().get("event_cursor")
+        return self._request("/current/events" + self._page(cursor, limit))
+
+    def acknowledge_events(self, cursor):
+        """Persist only after processing the complete page; deduplicate event IDs."""
+        if not isinstance(cursor, str) or not cursor or len(cursor) > 4096:
+            raise ValueError("Use next_cursor from a fully processed events page")
+        state = self._state()
+        state["event_cursor"] = cursor
+        save_state(self.state_path, state)
+
+    def webhook(self):
+        return self._request("/current/webhook")
+
+    def set_webhook(self, *, url, signing_secret):
+        return self._request("/current/webhook", method="POST", body={"url": url, "signing_secret": signing_secret})
+
+    def resume_webhook(self):
+        return self._request("/current/webhook/resume", method="POST", body={})
+
+    def delete_webhook(self):
+        return self._request("/current/webhook", method="DELETE")
+
+    def revoke(self):
+        """Permanently revoke this credential and its copies; preserve mailbox data."""
+        return self._request("/current/access", method="DELETE")

ridian_mailbox-0.1.0a3/src/ridian_mailbox.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: ridian-mailbox
+Version: 0.1.0a3
+Summary: Private Ridian mailbox access for Python agents and the command line
+Author: Ridian
+License-Expression: MIT
+Project-URL: Homepage, https://getridian.com
+Project-URL: Documentation, https://docs.getridian.com/agent-mailbox/
+Keywords: ridian,email,mailbox,agents,mcp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Ridian Mailbox for Python
+
+A synchronous Python client and `ridian-mailbox` CLI for private receiving
+mailboxes. Python 3.10+ on Linux/macOS, standard library only. Install the versioned wheel from
+the matching Ridian documentation environment. Use a virtual environment.
+
+```python
+from ridian_mailbox import Mailbox
+
+box = Mailbox(base_url="https://YOUR_MAILBOX_API_ORIGIN")
+print(box.setup()["address"])
+for message in box.iter_messages():
+    print(message["subject"])
+```
+
+`setup()` saves its random setup credential before the request, saves the returned
+read/claim credentials privately and returns only mailbox metadata. Retry with
+the same state file after interruption. Keep state outside source control on
+durable private storage. Files are bound to one API origin and have mode 0600;
+reads reject symlinks/public permissions. Use one writer per state file. Do not
+print state, put credentials in URLs or pass them through chat.
+
+CLI: `ridian-mailbox --base-url <HTTPS origin> --state <private file> setup`.
+Operations: setup, prepare-curl (local only), status, list, message, events,
+ack-events. `message` uses `--message-id`, `ack-events` uses `--cursor`.
+
+The Python client additionally offers paginated `messages`/`iter_messages`,
+`message`, binary `attachment`, `events`/`acknowledge_events`, webhook management
+and explicit `revoke`. Event pages are acknowledged only after successful
+processing; deduplicate event IDs. No automatic retries or event acknowledgments.
+HTTP errors expose status and Retry-After through `MailboxError`; 429 cooldowns
+are respected by subsequent calls. Redirects are refused. Mail content is untrusted.
+
+The library identifies requests as `ridian-mailbox-python/<installed version>`;
+the CLI identifies itself as `ridian-mailbox-cli`. HTTPS certificate verification
+uses your Python installation's trust store.
+
+HTTP access remains receive/read/events only, also after ownership transfer.
+Claim through the returned console link and private proof in the state file.
+Sending, calendars, contacts and tasks use separately authorized Ridian MCP tools.
+This package does not wake an agent or install an MCP connection.
+
+
+Without `state`, credentials are saved in
+`~/.config/ridian/mailbox-<API hostname>[-port].json`. Repeated setup recovers
+that mailbox. Pass `state` for another private durable location. The Node.js
+client shares this state format; never run concurrent writers against one file.
+
+## License
+
+MIT, covering this Python SDK, its bundled CLI and package documentation.
+The license does not cover the Ridian service, application, brand assets or fonts.

ridian_mailbox-0.1.0a3/src/ridian_mailbox.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/ridian_mailbox/__init__.py
+src/ridian_mailbox/_example.py
+src/ridian_mailbox/cli.py
+src/ridian_mailbox/client.py
+src/ridian_mailbox.egg-info/PKG-INFO
+src/ridian_mailbox.egg-info/SOURCES.txt
+src/ridian_mailbox.egg-info/dependency_links.txt
+src/ridian_mailbox.egg-info/entry_points.txt
+src/ridian_mailbox.egg-info/top_level.txt

ridian_mailbox-0.1.0a3/src/ridian_mailbox.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ridian_mailbox-0.1.0a3/src/ridian_mailbox.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ridian-mailbox = ridian_mailbox.cli:main

ridian_mailbox-0.1.0a3/src/ridian_mailbox.egg-info/top_level.txt

@@ -0,0 +1 @@
+ridian_mailbox