ctxd 0.1.0__tar.gz

ctxd-0.1.0/.gitignore

@@ -0,0 +1,173 @@
+secrets/*
+!secrets/.gitkeep
+.docker_env
+.env*
+!.env_example
+app_files/agent/*
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+benchmarking/arxiv_*/*
+
+scripts/data/*
+# C extensions
+*.so
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+.vscode/launch.json
+
+# Agent debug artifacts
+debug-artifacts/*
+!debug-artifacts/.gitkeep
+!debug-artifacts/README.md

ctxd-0.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: ctxd
+Version: 0.1.0
+Summary: Public Python SDK and CLI for the ctxd platform.
+Requires-Python: <3.13,>=3.11
+Requires-Dist: cryptography>=44.0.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: keyring>=25.7.0
+Requires-Dist: pydantic>=2.11.9
+Description-Content-Type: text/markdown
+
+# ctxd
+
+Public Python SDK and CLI for the `ctxd` platform.
+
+Install:
+
+```bash
+pip install ctxd
+```
+
+The SDK exposes sync and async clients:
+
+- `Client`
+- `AsyncClient`
+
+Authentication:
+
+1. Run `ctxd login` with the CLI to store OAuth credentials in a secure local store
+2. The CLI starts a device-style login session through the backend auth API
+3. The browser flow continues on `https://app.ctxd.dev/cli-login`, so login can finish on a different machine than the terminal session
+4. The backend dynamically registers the CLI session with the MCP authorization server and completes the OAuth callback server-side
+5. The SDK keeps only non-secret metadata in `~/.ctxd/config.json`
+6. The SDK reads the stored access token and refreshes it automatically when needed
+7. Tokens are loaded from the OS keychain when available, otherwise from an encrypted local credential store unlocked with a passphrase entered interactively or provided through `CTXD_PASSPHRASE`
+
+Base URL resolution order:
+
+1. `base_url=` passed to the client
+2. `CTXD_BASE_URL`
+3. `~/.ctxd/config.json`
+4. `https://mcp.ctxd.dev`
+
+Auth API URL resolution order:
+
+1. `CTXD_AUTH_API_URL`
+2. `https://api.ctxd.dev`
+
+Example:
+
+```python
+from ctxd import Client
+
+client = Client()
+
+results = client.search("text:deployment application:slack")
+profile = client.get_profile()
+document = client.fetch_document("doc-123")
+```
+
+Async example:
+
+```python
+from ctxd import AsyncClient
+
+async with AsyncClient() as client:
+    results = await client.search("text:deployment")
+```

ctxd-0.1.0/README.md

@@ -0,0 +1,57 @@
+# ctxd
+
+Public Python SDK and CLI for the `ctxd` platform.
+
+Install:
+
+```bash
+pip install ctxd
+```
+
+The SDK exposes sync and async clients:
+
+- `Client`
+- `AsyncClient`
+
+Authentication:
+
+1. Run `ctxd login` with the CLI to store OAuth credentials in a secure local store
+2. The CLI starts a device-style login session through the backend auth API
+3. The browser flow continues on `https://app.ctxd.dev/cli-login`, so login can finish on a different machine than the terminal session
+4. The backend dynamically registers the CLI session with the MCP authorization server and completes the OAuth callback server-side
+5. The SDK keeps only non-secret metadata in `~/.ctxd/config.json`
+6. The SDK reads the stored access token and refreshes it automatically when needed
+7. Tokens are loaded from the OS keychain when available, otherwise from an encrypted local credential store unlocked with a passphrase entered interactively or provided through `CTXD_PASSPHRASE`
+
+Base URL resolution order:
+
+1. `base_url=` passed to the client
+2. `CTXD_BASE_URL`
+3. `~/.ctxd/config.json`
+4. `https://mcp.ctxd.dev`
+
+Auth API URL resolution order:
+
+1. `CTXD_AUTH_API_URL`
+2. `https://api.ctxd.dev`
+
+Example:
+
+```python
+from ctxd import Client
+
+client = Client()
+
+results = client.search("text:deployment application:slack")
+profile = client.get_profile()
+document = client.fetch_document("doc-123")
+```
+
+Async example:
+
+```python
+from ctxd import AsyncClient
+
+async with AsyncClient() as client:
+    results = await client.search("text:deployment")
+```

ctxd-0.1.0/ctxd/__init__.py

@@ -0,0 +1,44 @@
+"""Public Python SDK for ctxd."""
+
+from ctxd._metadata import SDK_NAME, SDK_VERSION, get_user_agent
+from ctxd.async_client import AsyncClient
+from ctxd.auth import ensure_valid_credentials, login_with_browser, logout
+from ctxd.client import Client, CtxdClient
+from ctxd.config import (
+    DEFAULT_BASE_URL,
+    clear_credentials,
+    get_config_path,
+    load_config,
+    load_credentials,
+    save_config,
+    save_credentials,
+)
+from ctxd.exceptions import CtxdAuthError, CtxdError, CtxdProtocolError
+from ctxd.models import CredentialStore, DocumentResult, ProfileResult, SearchResult
+
+__all__ = [
+    "AsyncClient",
+    "Client",
+    "CredentialStore",
+    "CtxdClient",
+    "CtxdAuthError",
+    "CtxdError",
+    "CtxdProtocolError",
+    "DEFAULT_BASE_URL",
+    "DocumentResult",
+    "ProfileResult",
+    "SDK_NAME",
+    "SearchResult",
+    "__version__",
+    "clear_credentials",
+    "ensure_valid_credentials",
+    "get_config_path",
+    "get_user_agent",
+    "load_credentials",
+    "login_with_browser",
+    "load_config",
+    "logout",
+    "save_config",
+    "save_credentials",
+]
+__version__ = SDK_VERSION

ctxd-0.1.0/ctxd/_metadata.py

@@ -0,0 +1,6 @@
+SDK_NAME = "ctxd"
+SDK_VERSION = "0.1.0"
+
+
+def get_user_agent() -> str:
+    return f"{SDK_NAME}/{SDK_VERSION}"

ctxd-0.1.0/ctxd/async_client.py

@@ -0,0 +1,196 @@
+import asyncio
+import json
+from typing import Any
+
+import httpx
+
+from ctxd._metadata import get_user_agent
+from ctxd.auth import ensure_valid_credentials, login_with_browser, logout
+from ctxd.config import resolve_base_url
+from ctxd.exceptions import CtxdAuthError, CtxdError, CtxdProtocolError
+from ctxd.models import DocumentResult, ProfileResult, SearchResult
+
+
+class AsyncClient:
+    """Async client for the public ctxd MCP endpoint."""
+
+    def __init__(
+        self,
+        *,
+        access_token: str | None = None,
+        base_url: str | None = None,
+        client_id: str | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self._base_url = self._normalize_base_url(resolve_base_url(base_url))
+        self._access_token = access_token.strip() if access_token else None
+        self._client_id = client_id.strip() if client_id else None
+        self._timeout = timeout
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def base_url(self) -> str:
+        return self._base_url
+
+    @property
+    def client_id(self) -> str | None:
+        return self._client_id
+
+    async def __aenter__(self) -> "AsyncClient":
+        self._client = httpx.AsyncClient(timeout=self._timeout)
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        if self._client is not None:
+            await self._client.aclose()
+            self._client = None
+
+    async def search(self, query: str) -> SearchResult:
+        payload = await self.call_tool("search", {"query": query})
+        return SearchResult.model_validate(payload)
+
+    async def fetch_document(self, document_uid: str) -> DocumentResult:
+        payload = await self.call_tool("fetch_document", {"document_uid": document_uid})
+        return DocumentResult.model_validate(payload)
+
+    async def get_profile(self) -> ProfileResult:
+        payload = await self.call_tool("get_profile", {})
+        return ProfileResult.model_validate(payload)
+
+    async def login(self, *, open_browser: bool = True, timeout_seconds: float = 300.0):
+        return await _run_sync(
+            login_with_browser,
+            base_url=self._base_url,
+            timeout_seconds=timeout_seconds,
+            open_browser=open_browser,
+        )
+
+    def logout(self, *, keep_base_url: bool = True) -> None:
+        logout(keep_base_url=keep_base_url)
+
+    async def call_tool(self, name: str, arguments: dict[str, Any]) -> dict[str, Any]:
+        request_body = {
+            "jsonrpc": "2.0",
+            "method": "tools/call",
+            "params": {
+                "name": name,
+                "arguments": arguments,
+            },
+            "id": 1,
+        }
+        token = await self._resolve_access_token()
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Accept": "application/json, text/event-stream",
+            "User-Agent": get_user_agent(),
+        }
+
+        if self._client is not None:
+            response = await self._client.post(
+                self._base_url,
+                headers=headers,
+                json=request_body,
+            )
+        else:
+            async with httpx.AsyncClient(timeout=self._timeout) as client:
+                response = await client.post(
+                    self._base_url,
+                    headers=headers,
+                    json=request_body,
+                )
+
+        return self._parse_response(response)
+
+    async def _resolve_access_token(self) -> str:
+        if self._access_token:
+            return self._access_token
+
+        credentials = await _run_sync(
+            ensure_valid_credentials,
+            base_url=self._base_url,
+            client_id=self._client_id,
+        )
+        if not credentials.access_token:
+            raise CtxdAuthError("Missing access token. Run `ctxd login` first.")
+        return credentials.access_token
+
+    @staticmethod
+    def _normalize_base_url(base_url: str) -> str:
+        normalized = base_url.rstrip("/")
+        if normalized.endswith("/sse"):
+            normalized = normalized[: -len("/sse")]
+        if not normalized.endswith("/mcp"):
+            normalized = f"{normalized}/mcp"
+        return normalized
+
+    @staticmethod
+    def _parse_response(response: httpx.Response) -> dict[str, Any]:
+        if response.status_code >= 400:
+            message = f"ctxd MCP request failed with status {response.status_code}"
+            try:
+                error_payload = response.json()
+            except ValueError:
+                error_payload = response.text
+            raise CtxdError(
+                message, status_code=response.status_code, payload=error_payload
+            )
+
+        content_type = response.headers.get("content-type", "")
+        if "text/event-stream" in content_type:
+            return AsyncClient._parse_sse_payload(response.text)
+        if "application/json" in content_type:
+            return AsyncClient._parse_json_payload(response.json())
+
+        if response.text.startswith("event:") or response.text.startswith("data:"):
+            return AsyncClient._parse_sse_payload(response.text)
+
+        raise CtxdProtocolError(
+            f"Unsupported MCP response content type: {content_type or 'unknown'}"
+        )
+
+    @staticmethod
+    def _parse_sse_payload(raw_text: str) -> dict[str, Any]:
+        data_line = next(
+            (line for line in raw_text.splitlines() if line.startswith("data: ")),
+            None,
+        )
+        if data_line is None:
+            raise CtxdProtocolError("MCP SSE response did not contain a data line")
+
+        body = json.loads(data_line[len("data: ") :])
+        return AsyncClient._parse_json_payload(body)
+
+    @staticmethod
+    def _parse_json_payload(body: dict[str, Any]) -> dict[str, Any]:
+        if "error" in body:
+            raise CtxdError("MCP JSON-RPC error", payload=body["error"])
+
+        result = body.get("result")
+        if not isinstance(result, dict):
+            raise CtxdProtocolError("MCP response did not include a result object")
+
+        content = result.get("content")
+        if not isinstance(content, list) or not content:
+            raise CtxdProtocolError("MCP result content was missing or empty")
+
+        first_item = content[0]
+        if first_item.get("type") != "text":
+            raise CtxdProtocolError("MCP result content item was not text")
+
+        text = first_item.get("text")
+        if not isinstance(text, str):
+            raise CtxdProtocolError("MCP result text payload was not a string")
+
+        if result.get("isError"):
+            raise CtxdError(text, payload=result)
+
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError as exc:
+            raise CtxdProtocolError(
+                "MCP result text payload was not valid JSON"
+            ) from exc
+
+
+async def _run_sync(func, /, *args, **kwargs):
+    return await asyncio.to_thread(func, *args, **kwargs)