cloudrift-mcp 0.1.0__py3-none-any.whl

cloudrift_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""cloudrift-mcp: read-only MCP access to a CloudRift tenant's own data."""
+
+__version__ = "0.1.0"

cloudrift_mcp/client.py

@@ -0,0 +1,102 @@
+"""HTTP access to the CloudRift public API (read-only GETs).
+
+Configuration comes from the environment ONLY:
+
+    CLOUDRIFT_API_KEY   required. A CloudRift API key (crk_live_...).
+                        Without it the server still starts, but every
+                        tool returns a clear CONFIG error.
+    CLOUDRIFT_API_URL   optional. Defaults to https://cloudrift.tech.
+
+The key is sent as `Authorization: Bearer <key>`. It is never accepted
+as a tool argument and never echoed into any tool result or error
+message. All requests are GETs with a 30 second timeout; failures are
+returned as honest one-line tool errors (status + the API's own
+detail), never stack traces.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, Optional
+
+import httpx
+
+from .errors import API_ERROR, CONFIG, NETWORK_ERROR, tool_error
+
+DEFAULT_API_URL = "https://cloudrift.tech"
+TIMEOUT_SECONDS = 30.0
+
+# Tests set this to an httpx.MockTransport; production leaves it None.
+transport: Optional[httpx.BaseTransport] = None
+
+
+def base_url() -> str:
+    """The API origin, from CLOUDRIFT_API_URL, without a trailing slash."""
+    return (os.environ.get("CLOUDRIFT_API_URL") or DEFAULT_API_URL).rstrip("/")
+
+
+def _api_key() -> str:
+    key = (os.environ.get("CLOUDRIFT_API_KEY") or "").strip()
+    if not key:
+        raise tool_error(
+            CONFIG,
+            "CLOUDRIFT_API_KEY is not set. Create a read-only API key in "
+            "CloudRift (Settings > API Keys) and export it in the "
+            "environment of this MCP server; keys are never accepted as "
+            "tool arguments.")
+    return key
+
+
+def get(path: str, params: Optional[Dict[str, Any]] = None) -> Any:
+    """GET an /api/v1 path and return the parsed JSON body.
+
+    `path` is the part after the origin, e.g. "/api/v1/resources".
+    Raises a ToolError (CONFIG / NETWORK_ERROR / API_ERROR) on any
+    failure; the message carries the status and the API's own `detail`
+    when there is one.
+    """
+    url = base_url() + path
+    headers = {"Authorization": "Bearer " + _api_key()}
+    try:
+        with httpx.Client(timeout=TIMEOUT_SECONDS, transport=transport) as http:
+            response = http.get(url, params=params or {}, headers=headers)
+    except httpx.TimeoutException:
+        raise tool_error(
+            NETWORK_ERROR,
+            f"GET {path} timed out after {int(TIMEOUT_SECONDS)}s "
+            f"({base_url()}).") from None
+    except httpx.HTTPError as exc:
+        # One honest line (e.g. connection refused), never a traceback.
+        raise tool_error(
+            NETWORK_ERROR,
+            f"could not reach {base_url()}: {exc.__class__.__name__}: "
+            f"{exc}") from None
+
+    if response.status_code >= 400:
+        raise tool_error(
+            API_ERROR,
+            f"CloudRift API returned {response.status_code} for GET {path}: "
+            f"{_api_detail(response)}")
+
+    try:
+        return response.json()
+    except ValueError:
+        raise tool_error(
+            API_ERROR,
+            f"CloudRift API returned a non-JSON body for GET {path} "
+            f"(status {response.status_code}).") from None
+
+
+def _api_detail(response: httpx.Response) -> str:
+    """The API's own `detail` string, else a truncated body, else the
+    HTTP reason phrase."""
+    try:
+        body = response.json()
+        if isinstance(body, dict) and body.get("detail"):
+            return str(body["detail"])
+    except ValueError:
+        pass
+    text = (response.text or "").strip()
+    if text:
+        return text[:200]
+    return response.reason_phrase or "no detail provided"

cloudrift_mcp/errors.py

@@ -0,0 +1,19 @@
+"""Structured tool errors.
+
+Every failure a tool can hit is raised as a ToolError whose message
+starts with a stable code, so an agent (or a human reading an editor
+pane) gets "CODE: one clear sentence" and never a stack trace. The MCP
+SDK converts a raised ToolError into an is_error tool result.
+"""
+
+from mcp.server.mcpserver.exceptions import ToolError
+
+CONFIG = "CONFIG"
+INVALID_ARGUMENT = "INVALID_ARGUMENT"
+API_ERROR = "API_ERROR"
+NETWORK_ERROR = "NETWORK_ERROR"
+
+
+def tool_error(code: str, message: str) -> ToolError:
+    """Build (not raise) a ToolError with the standard CODE: message shape."""
+    return ToolError(f"{code}: {message}")

cloudrift_mcp/server.py

@@ -0,0 +1,299 @@
+"""cloudrift-mcp stdio server.
+
+Five read-only tools over the CloudRift public REST API (/api/v1), so
+an AI assistant can query the customer's OWN cloud-waste findings and
+verified-savings receipts. Every tool is a GET scoped by the API key's
+tenant; nothing here can mutate, delete, or reach another tenant.
+
+Credentials policy: no tool accepts a credential argument, ever. The
+API key comes from the CLOUDRIFT_API_KEY environment variable only
+(see client.py). Without it the server still starts and each tool
+returns a clear CONFIG error.
+
+Output policy: responses are trimmed to the fields an assistant needs.
+Every list is capped, and the cap is stated in the result itself, so a
+partial view is never silent.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Any, Dict, List, Optional, Tuple
+
+from mcp.server.mcpserver import MCPServer
+from mcp.types import ToolAnnotations
+
+from . import __version__, client
+from .errors import INVALID_ARGUMENT, tool_error
+
+_READ_ONLY = ToolAnnotations(readOnlyHint=True, destructiveHint=False,
+                             openWorldHint=False)
+
+# The API serves at most 200 items per page; we walk at most this many
+# pages per tool call so one call can never trigger an unbounded crawl.
+PAGE_SIZE = 200
+MAX_PAGES = 5
+
+# Caps on what a tool returns inline. Stated in every capped result.
+DEFAULT_FINDINGS_LIMIT = 25
+MAX_FINDINGS_LIMIT = 100
+RECOMMENDATIONS_CAP = 50
+RECEIPT_ENTRIES_CAP = 50
+BUDGETS_CAP = 50
+ACCOUNTS_CAP = 50
+
+mcp = MCPServer("cloudrift-mcp", version=__version__)
+
+
+def _fetch_pages(path: str, params: Optional[Dict[str, Any]] = None,
+                 ) -> Tuple[List[dict], int]:
+    """Walk a paginated /api/v1 list endpoint.
+
+    Returns (items, total_reported_by_api). Fetches at most MAX_PAGES
+    pages of PAGE_SIZE, so items may be a bounded prefix of the total;
+    callers compare len(items) to the total and say so.
+    """
+    items: List[dict] = []
+    total = 0
+    for page in range(1, MAX_PAGES + 1):
+        query = dict(params or {})
+        query.update({"page": page, "page_size": PAGE_SIZE})
+        body = client.get(path, query)
+        data = body.get("data") if isinstance(body, dict) else None
+        pagination = body.get("pagination", {}) if isinstance(body, dict) else {}
+        page_items = data if isinstance(data, list) else []
+        items.extend(d for d in page_items if isinstance(d, dict))
+        try:
+            total = int(pagination.get("total", len(items)))
+        except (TypeError, ValueError):
+            total = len(items)
+        if len(page_items) < PAGE_SIZE or len(items) >= total:
+            break
+    return items, max(total, len(items))
+
+
+def _money(value: Any) -> float:
+    """Non-negative float dollars; bad input counts as 0."""
+    try:
+        n = float(value)
+    except (TypeError, ValueError):
+        return 0.0
+    if n != n or n in (float("inf"), float("-inf")) or n < 0:
+        return 0.0
+    return n
+
+
+def _is_waste(resource: dict) -> bool:
+    """A resource is a waste finding when the scanner flagged it as
+    orphaned, or recorded a non-empty optimization potential."""
+    if resource.get("is_orphaned"):
+        return True
+    potential = resource.get("optimization_potential")
+    if potential is None:
+        return False
+    return str(potential).strip().lower() not in ("", "none", "null", "0")
+
+
+@mcp.tool(annotations=_READ_ONLY)
+def list_waste_findings(account_id: Optional[str] = None,
+                        limit: Optional[int] = None) -> Dict[str, Any]:
+    """List the tenant's cloud-waste findings from its latest scans:
+    orphaned (unattached / unused) resources first, then resources with
+    optimization potential, each ordered by monthly cost descending.
+
+    account_id restricts to one cloud account (404 if it is not yours).
+    limit caps the findings returned (default 25, max 100); the result
+    states how many findings matched in total, and the summed monthly
+    cost of ALL matching findings, so totals never depend on the cap.
+    Read-only; reads /api/v1/resources with your CLOUDRIFT_API_KEY.
+    """
+    if limit is None:
+        limit = DEFAULT_FINDINGS_LIMIT
+    if limit < 1 or limit > MAX_FINDINGS_LIMIT:
+        raise tool_error(
+            INVALID_ARGUMENT,
+            f"limit must be between 1 and {MAX_FINDINGS_LIMIT}.")
+
+    params: Dict[str, Any] = {}
+    if account_id:
+        params["account_id"] = account_id
+    resources, total_resources = _fetch_pages("/api/v1/resources", params)
+
+    findings = [r for r in resources if _is_waste(r)]
+    findings.sort(key=lambda r: (0 if r.get("is_orphaned") else 1,
+                                 -_money(r.get("monthly_cost"))))
+    shown = findings[:limit]
+
+    note = (f"Showing {len(shown)} of {len(findings)} waste findings, "
+            f"orphaned first, then monthly cost descending "
+            f"(limit={limit}, max {MAX_FINDINGS_LIMIT}).")
+    if len(resources) < total_resources:
+        note += (f" Scanned the first {len(resources)} of {total_resources} "
+                 f"resources; pass account_id to narrow the scan.")
+
+    return {
+        "findings": [{
+            "id": r.get("id"),
+            "name": r.get("name"),
+            "type": r.get("type"),
+            "location": r.get("location"),
+            "resource_group": r.get("resource_group"),
+            "status": r.get("status"),
+            "monthly_cost": round(_money(r.get("monthly_cost")), 2),
+            "is_orphaned": bool(r.get("is_orphaned")),
+            "optimization_potential": r.get("optimization_potential"),
+            "account_id": r.get("account_id"),
+        } for r in shown],
+        "waste_findings_total": len(findings),
+        "orphaned_total": sum(1 for r in findings if r.get("is_orphaned")),
+        "monthly_waste_cost_total": round(
+            sum(_money(r.get("monthly_cost")) for r in findings), 2),
+        "resources_scanned": len(resources),
+        "note": note,
+    }
+
+
+@mcp.tool(annotations=_READ_ONLY)
+def get_recommendations(account_id: Optional[str] = None) -> Dict[str, Any]:
+    """List the tenant's optimization recommendations (what to delete,
+    resize, or reconfigure and the estimated monthly saving for each),
+    ordered by estimated monthly savings descending.
+
+    account_id filters to one cloud account (applied locally; the API
+    returns all accounts). At most 50 recommendations are returned
+    inline; the result states the full matching count and the summed
+    estimated savings across ALL matches. Read-only; reads
+    /api/v1/recommendations with your CLOUDRIFT_API_KEY.
+    """
+    recs, _total = _fetch_pages("/api/v1/recommendations")
+    if account_id:
+        recs = [r for r in recs if r.get("account_id") == account_id]
+    recs.sort(key=lambda r: -_money(r.get("estimated_monthly_savings")))
+    shown = recs[:RECOMMENDATIONS_CAP]
+
+    return {
+        "recommendations": [{
+            "resource_id": r.get("resource_id"),
+            "resource_name": r.get("resource_name"),
+            "resource_type": r.get("resource_type"),
+            "priority": r.get("priority"),
+            "category": r.get("category"),
+            "issue": r.get("issue"),
+            "action": r.get("action"),
+            "estimated_monthly_savings": round(
+                _money(r.get("estimated_monthly_savings")), 2),
+            "account_id": r.get("account_id"),
+        } for r in shown],
+        "recommendations_total": len(recs),
+        "estimated_monthly_savings_total": round(
+            sum(_money(r.get("estimated_monthly_savings")) for r in recs), 2),
+        "note": (f"Showing {len(shown)} of {len(recs)} recommendations, "
+                 f"estimated monthly savings descending "
+                 f"(cap {RECOMMENDATIONS_CAP})."),
+    }
+
+
+@mcp.tool(annotations=_READ_ONLY)
+def get_cost_summary() -> Dict[str, Any]:
+    """Roll-up of the tenant's current monthly cloud spend and waste:
+    total monthly cost, orphaned (waste) monthly cost, annual savings
+    potential, resource counts, per-account breakdown, and the latest
+    scan date. These are the same canonical numbers the CloudRift
+    dashboard shows. Read-only; reads /api/v1/costs/summary with your
+    CLOUDRIFT_API_KEY.
+    """
+    body = client.get("/api/v1/costs/summary")
+    data = body.get("data") if isinstance(body, dict) else None
+    if not isinstance(data, dict):
+        data = {}
+    accounts = data.get("accounts") or []
+    shown_accounts = accounts[:ACCOUNTS_CAP]
+
+    result = {
+        "currency": data.get("currency", "USD"),
+        "total_monthly_cost": data.get("total_monthly_cost"),
+        "orphaned_monthly_cost": data.get("orphaned_monthly_cost"),
+        "annual_savings_potential": data.get("annual_savings_potential"),
+        "total_resources": data.get("total_resources"),
+        "orphaned_count": data.get("orphaned_count"),
+        "latest_scan_date": data.get("latest_scan_date"),
+        "accounts": shown_accounts,
+    }
+    if len(accounts) > len(shown_accounts):
+        result["note"] = (f"Showing {len(shown_accounts)} of {len(accounts)} "
+                          f"accounts (cap {ACCOUNTS_CAP}); the totals above "
+                          f"cover all accounts.")
+    return result
+
+
+@mcp.tool(annotations=_READ_ONLY)
+def get_savings_receipts() -> Dict[str, Any]:
+    """The tenant's verified-savings ledger: receipts for savings
+    CloudRift actually executed, each labelled by verification status
+    (estimated / confirmed / billing_verified), with per-status totals
+    and the returned-to-date figure. The `basis` string from the API is
+    passed through verbatim - it states exactly how returned_to_date is
+    computed, so the number is always labelled as the extrapolation it
+    is. Requires CloudRift >= 2026-09-30. Read-only; reads
+    /api/v1/receipts with your CLOUDRIFT_API_KEY.
+    """
+    body = client.get("/api/v1/receipts",
+                      {"page": 1, "page_size": RECEIPT_ENTRIES_CAP})
+    data = body.get("data") if isinstance(body, dict) else None
+    if not isinstance(data, dict):
+        data = {}
+    entries = data.get("entries") or []
+    shown = entries[:RECEIPT_ENTRIES_CAP]
+    pagination = body.get("pagination", {}) if isinstance(body, dict) else {}
+    try:
+        total = int(pagination.get("total", len(entries)))
+    except (TypeError, ValueError):
+        total = len(entries)
+    total = max(total, len(entries))
+
+    return {
+        "totals": data.get("totals") or {},
+        "basis": data.get("basis"),
+        "entries": shown,
+        "entries_total": total,
+        "note": (f"Showing {len(shown)} of {total} ledger entries, newest "
+                 f"first (cap {RECEIPT_ENTRIES_CAP}); totals and basis cover "
+                 f"the full ledger and are reproduced verbatim from the "
+                 f"API."),
+    }
+
+
+@mcp.tool(annotations=_READ_ONLY)
+def get_budgets() -> Dict[str, Any]:
+    """The tenant's configured spend budgets: per-account monthly
+    limits with warning / critical thresholds and whether each budget
+    is enabled. Read-only; reads /api/v1/budgets with your
+    CLOUDRIFT_API_KEY.
+    """
+    body = client.get("/api/v1/budgets")
+    data = body.get("data") if isinstance(body, dict) else None
+    budgets = data if isinstance(data, list) else []
+    shown = budgets[:BUDGETS_CAP]
+
+    result: Dict[str, Any] = {
+        "budgets": shown,
+        "budgets_total": len(budgets),
+    }
+    if len(budgets) > len(shown):
+        result["note"] = (f"Showing {len(shown)} of {len(budgets)} budgets "
+                          f"(cap {BUDGETS_CAP}).")
+    return result
+
+
+def main() -> None:
+    """Entry point for `uvx cloudrift-mcp`."""
+    if not (os.environ.get("CLOUDRIFT_API_KEY") or "").strip():
+        print("cloudrift-mcp: CLOUDRIFT_API_KEY is not set; the server will "
+              "run, but every tool will return a CONFIG error until you "
+              "export a CloudRift API key", file=sys.stderr)
+    mcp.run("stdio")
+
+
+if __name__ == "__main__":
+    main()

cloudrift_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: cloudrift-mcp
+Version: 0.1.0
+Summary: Read-only MCP server exposing CloudRift cloud-waste findings and verified-savings receipts to AI assistants
+Author-email: CloudRift <support@cloudrift.tech>
+License: MIT
+Project-URL: Homepage, https://cloudrift.tech
+Keywords: mcp,cloudrift,finops,cloud-cost,waste,savings
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<3,>=2
+Requires-Dist: httpx>=0.27
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+# cloudrift-mcp
+
+An [MCP](https://modelcontextprotocol.io) server that gives your AI
+assistant (Claude Code, Claude Desktop, Cursor, and any other MCP
+client) read-only access to your own
+[CloudRift](https://cloudrift.tech) data: cloud-waste findings,
+optimization recommendations, cost summaries, budgets, and the
+verified-savings ledger. The thesis is simple: in the agent era, your
+cost data should be queryable by the assistants you already work in -
+"what are my ten most expensive orphaned resources?" or "how much has
+CloudRift actually saved us, and how is that number computed?" should
+be one question away, answered from your tenant's live findings and
+receipts rather than a stale export.
+
+Read-only by construction. Every tool is a GET against the CloudRift
+public API, scoped to the tenant that owns the API key. No tool
+mutates anything, and no tool accepts a credential argument - the key
+comes from the environment only.
+
+## Quickstart
+
+Requires Python 3.10+ and [uv](https://docs.astral.sh/uv/), or pip:
+
+```
+uvx cloudrift-mcp        # no install step
+pip install cloudrift-mcp && cloudrift-mcp
+```
+
+Create an API key in CloudRift (Settings > API Keys) with read-only
+scopes, then export it as `CLOUDRIFT_API_KEY`.
+
+### Claude Code
+
+```
+claude mcp add cloudrift --env CLOUDRIFT_API_KEY=crk_live_... -- uvx cloudrift-mcp
+```
+
+### Claude Desktop
+
+Add to `claude_desktop_config.json` (Settings > Developer > Edit
+Config):
+
+```json
+{
+  "mcpServers": {
+    "cloudrift": {
+      "command": "uvx",
+      "args": ["cloudrift-mcp"],
+      "env": {
+        "CLOUDRIFT_API_KEY": "crk_live_..."
+      }
+    }
+  }
+}
+```
+
+## Environment variables
+
+| Variable            | Required | Meaning                                            |
+| ------------------- | -------- | -------------------------------------------------- |
+| `CLOUDRIFT_API_KEY` | yes      | A CloudRift API key. Without it the server starts, but every tool returns a clear CONFIG error. |
+| `CLOUDRIFT_API_URL` | no       | API origin; defaults to `https://cloudrift.tech`.  |
+
+## Tools
+
+All tools are read-only GETs with a 30 second timeout. Lists are
+capped, and every capped result states the cap and the full totals, so
+a partial view is never silent.
+
+| Tool                  | Arguments                   | Endpoint                  | Returns |
+| --------------------- | --------------------------- | ------------------------- | ------- |
+| `list_waste_findings` | `account_id?`, `limit?` (default 25, max 100) | `/api/v1/resources` | Waste findings: orphaned resources first, then optimization candidates, monthly cost descending, with full waste totals. |
+| `get_recommendations` | `account_id?` (filtered locally) | `/api/v1/recommendations` | Optimization recommendations, estimated monthly savings descending (top 50), with the summed savings across all matches. |
+| `get_cost_summary`    | -                           | `/api/v1/costs/summary`   | Monthly spend, orphaned (waste) cost, annual savings potential, per-account breakdown, latest scan date. |
+| `get_savings_receipts`| -                           | `/api/v1/receipts`        | The verified-savings ledger: entries labelled estimated / confirmed / billing_verified, per-status totals, and the API's `basis` string verbatim (how returned_to_date is computed). Requires CloudRift >= 2026-09-30. |
+| `get_budgets`         | -                           | `/api/v1/budgets`         | Configured spend budgets with warning / critical thresholds. |
+
+Errors come back as one honest line - `API_ERROR: CloudRift API
+returned 403 for GET /api/v1/costs/summary: This API key is missing
+the required scope: read:costs.` - never a stack trace.
+
+## Security
+
+- **Use a read-only key.** Grant only the `read:*` scopes
+  (`read:resources`, `read:recommendations`, `read:costs`,
+  `read:budgets`) when you mint the key. This server only ever issues
+  GETs, so a broader key buys nothing and risks more.
+- **Env-only auth.** The key is read from `CLOUDRIFT_API_KEY` and sent
+  as `Authorization: Bearer`. No tool accepts a key as an argument (a
+  test enforces that no credential-shaped field exists in any tool
+  schema), and the key is never echoed into tool results or error
+  messages.
+- **Tenant-scoped by the API.** The CloudRift public API scopes every
+  query to the key owner's account; this server adds no cross-tenant
+  reach.
+- **Bounded requests.** At most five pages of 200 items are fetched
+  per tool call, and CloudRift rate-limits each key to 120
+  requests/minute.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

cloudrift_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+cloudrift_mcp/__init__.py,sha256=SMYnCQy6QjgSAwDN_EiBnNz8c1liz_2wFE2ua665qMI,99
+cloudrift_mcp/client.py,sha256=Bxke3QEnVSQpRZ3UdzllrD_whD1fd1lzzJJsx0KK_zk,3613
+cloudrift_mcp/errors.py,sha256=6ccLC8rycbHAjkDMwEvx1J-DgcNBDHwtD_KFW3wiRP8,648
+cloudrift_mcp/server.py,sha256=RTI3pnkK4JRk9k-LhyyUlg_Ct6RWHs_94zt2dHDNrEw,11993
+cloudrift_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=L_qSw9VP9ScLYsbHoWyY6j6FNRGHMwTjybu3jgLVGxI,1066
+cloudrift_mcp-0.1.0.dist-info/METADATA,sha256=5IQxQeccJ6FR8dgebXs7TBCS7_KIMMeSZoM_jmXKzKI,5504
+cloudrift_mcp-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+cloudrift_mcp-0.1.0.dist-info/entry_points.txt,sha256=y6451uf64-Fz5QGT4LZy4DeuX9TZTaInwM81v-b8FTA,60
+cloudrift_mcp-0.1.0.dist-info/top_level.txt,sha256=srVTyO2v6dpUU_oced1X9VHkHljxDDdDpKrB6-X38ZU,14
+cloudrift_mcp-0.1.0.dist-info/RECORD,,

cloudrift_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cloudrift_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cloudrift-mcp = cloudrift_mcp.server:main

cloudrift_mcp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CloudRift
+
+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.

cloudrift_mcp-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cloudrift_mcp