cloudcost-cli 0.1.0__py3-none-any.whl

backend/app/model_pricing.py

@@ -0,0 +1,80 @@
+import json
+from functools import lru_cache
+from importlib.util import find_spec
+from pathlib import Path
+from typing import Any
+
+
+MODEL_ALIASES = {
+    "opus": {"label": "Claude Opus 4.7", "litellm_model": "claude-opus-4-7"},
+    "sonnet": {"label": "Claude Sonnet 4.6", "litellm_model": "claude-sonnet-4-6"},
+    "haiku": {"label": "Claude Haiku 4.5", "litellm_model": "claude-haiku-4-5"},
+    "gpt4o": {"label": "GPT-4o", "litellm_model": "gpt-4o"},
+    "gpt4omini": {"label": "GPT-4o mini", "litellm_model": "gpt-4o-mini"},
+    "gpt5mini": {"label": "GPT-5 mini", "litellm_model": "gpt-5-mini"},
+    "gemini": {"label": "Gemini 2.5 Pro", "litellm_model": "gemini/gemini-2.5-pro"},
+}
+
+FALLBACK_MODEL_RATES = {
+    "opus": {"label": "Claude Opus 4.7", "input_per_1m": 5.00, "output_per_1m": 25.00},
+    "sonnet": {"label": "Claude Sonnet 4.6", "input_per_1m": 3.00, "output_per_1m": 15.00},
+    "haiku": {"label": "Claude Haiku 4.5", "input_per_1m": 1.00, "output_per_1m": 5.00},
+    "gpt4o": {"label": "GPT-4o", "input_per_1m": 2.50, "output_per_1m": 10.00},
+    "gpt4omini": {"label": "GPT-4o mini", "input_per_1m": 0.15, "output_per_1m": 0.60},
+    "gpt5mini": {"label": "GPT-5 mini", "input_per_1m": 0.25, "output_per_1m": 2.00},
+    "gemini": {"label": "Gemini 2.5 Pro", "input_per_1m": 1.25, "output_per_1m": 10.00},
+}
+
+
+def _litellm_pricing_path() -> Path | None:
+    spec = find_spec("litellm")
+    if not spec or not spec.submodule_search_locations:
+        return None
+    package_dir = Path(next(iter(spec.submodule_search_locations)))
+    for filename in (
+        "model_prices_and_context_window.json",
+        "model_prices_and_context_window_backup.json",
+    ):
+        candidate = package_dir / filename
+        if candidate.exists():
+            return candidate
+    return None
+
+
+@lru_cache
+def load_litellm_price_map() -> tuple[dict[str, Any], str | None]:
+    path = _litellm_pricing_path()
+    if not path:
+        return {}, None
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}, None
+    return payload if isinstance(payload, dict) else {}, str(path)
+
+
+def _per_million(value: Any) -> float | None:
+    if value is None:
+        return None
+    return round(float(value) * 1_000_000, 6)
+
+
+def get_model_rates() -> tuple[dict[str, dict[str, Any]], str]:
+    price_map, source_path = load_litellm_price_map()
+    rates: dict[str, dict[str, Any]] = {}
+
+    for alias, meta in MODEL_ALIASES.items():
+        fallback = FALLBACK_MODEL_RATES[alias]
+        model_key = meta["litellm_model"]
+        local = price_map.get(model_key, {})
+        input_per_1m = _per_million(local.get("input_cost_per_token"))
+        output_per_1m = _per_million(local.get("output_cost_per_token"))
+        rates[alias] = {
+            "label": meta["label"],
+            "litellm_model": model_key,
+            "input_per_1m": input_per_1m if input_per_1m is not None else fallback["input_per_1m"],
+            "output_per_1m": output_per_1m if output_per_1m is not None else fallback["output_per_1m"],
+        }
+
+    source = "litellm_local" if source_path else "fallback"
+    return rates, source

backend/app/security.py

@@ -0,0 +1,15 @@
+import hashlib
+import hmac
+
+
+def verify_github_signature(payload_body: bytes, secret_token: str, signature_header: str | None) -> bool:
+    if not signature_header:
+        return False
+
+    expected_signature = "sha256=" + hmac.new(
+        secret_token.encode("utf-8"),
+        msg=payload_body,
+        digestmod=hashlib.sha256,
+    ).hexdigest()
+
+    return hmac.compare_digest(expected_signature, signature_header)

backend/app/storage.py

@@ -0,0 +1,31 @@
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+def append_jsonl(path: str, record: dict[str, Any]) -> None:
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "recorded_at": datetime.now(timezone.utc).isoformat(),
+        **record,
+    }
+    with target.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(payload, sort_keys=True, separators=(",", ":")) + "\n")
+
+
+def read_jsonl(path: str, limit: int = 1000) -> list[dict[str, Any]]:
+    target = Path(path)
+    if not target.exists():
+        return []
+
+    rows: list[dict[str, Any]] = []
+    with target.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            line = line.strip()
+            if not line:
+                continue
+            rows.append(json.loads(line))
+
+    return rows[-limit:]

backend/app/usage.py

@@ -0,0 +1,73 @@
+from collections import defaultdict
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+FORBIDDEN_PAYLOAD_KEYS = {
+    "messages",
+    "prompt",
+    "input",
+    "output",
+    "response",
+    "completion",
+    "choices",
+}
+
+
+class UsageEvent(BaseModel):
+    event_type: str = "success"
+    model: str | None = None
+    user: str | None = None
+    key_alias: str | None = None
+    team_id: str | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    usage: dict[str, Any] = Field(default_factory=dict)
+    cost: float | None = None
+    started_at: str | None = None
+    ended_at: str | None = None
+
+
+def _sanitize_value(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {
+            key: _sanitize_value(inner)
+            for key, inner in value.items()
+            if str(key).lower() not in FORBIDDEN_PAYLOAD_KEYS
+        }
+    if isinstance(value, list):
+        return [_sanitize_value(item) for item in value]
+    return value
+
+
+def sanitize_usage_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    return _sanitize_value(payload)
+
+
+def summarize_usage(events: list[dict[str, Any]]) -> dict[str, Any]:
+    by_model: dict[str, dict[str, float]] = defaultdict(lambda: {"cost": 0.0, "tokens": 0.0})
+    by_user: dict[str, dict[str, float]] = defaultdict(lambda: {"cost": 0.0, "tokens": 0.0})
+    total_cost = 0.0
+    total_tokens = 0.0
+
+    for event in events:
+        cost = float(event.get("cost") or 0.0)
+        usage = event.get("usage") or {}
+        tokens = float(usage.get("total_tokens") or 0.0)
+        model = event.get("model") or "unknown"
+        user = event.get("user") or "unknown"
+
+        total_cost += cost
+        total_tokens += tokens
+        by_model[model]["cost"] += cost
+        by_model[model]["tokens"] += tokens
+        by_user[user]["cost"] += cost
+        by_user[user]["tokens"] += tokens
+
+    return {
+        "events": len(events),
+        "total_cost": round(total_cost, 8),
+        "total_tokens": int(total_tokens),
+        "by_model": dict(by_model),
+        "by_user": dict(by_user),
+    }

cloudcost_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,340 @@
+Metadata-Version: 2.4
+Name: cloudcost-cli
+Version: 0.1.0
+Summary: CloudCost CLI for Terraform cost estimates and GitHub pull request cost automation.
+Author: CloudCost AI
+Project-URL: Homepage, https://cloudcost.live
+Project-URL: Documentation, https://cloudcost.live/docs/cloudcost-cli.html
+Project-URL: Source, https://github.com/zedxod/cloudcost
+Keywords: finops,terraform,infracost,github,cloud-cost,llm-cost
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic-settings>=2.5.0
+Provides-Extra: server
+Requires-Dist: fastapi>=0.115.0; extra == "server"
+Requires-Dist: litellm[proxy]>=1.85.0; extra == "server"
+Requires-Dist: prisma>=0.15.0; extra == "server"
+Requires-Dist: psycopg[binary]>=3.2.0; extra == "server"
+Requires-Dist: PyJWT[crypto]>=2.9.0; extra == "server"
+Requires-Dist: python-multipart>=0.0.12; extra == "server"
+Requires-Dist: uvicorn[standard]>=0.30.0; extra == "server"
+Provides-Extra: dev
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: fastapi>=0.115.0; extra == "dev"
+Requires-Dist: litellm[proxy]>=1.85.0; extra == "dev"
+Requires-Dist: prisma>=0.15.0; extra == "dev"
+Requires-Dist: psycopg[binary]>=3.2.0; extra == "dev"
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: PyJWT[crypto]>=2.9.0; extra == "dev"
+Requires-Dist: python-multipart>=0.0.12; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+Requires-Dist: uvicorn[standard]>=0.30.0; extra == "dev"
+
+# CloudCost AI
+
+CloudCost AI is a developer-first FinOps MVP. It has two mechanisms:
+
+1. An AI spend proxy powered by LiteLLM.
+2. A GitHub App webhook that estimates Terraform cost deltas in pull requests with Infracost.
+
+The landing page is served from `index.html`; the working backend is in `backend/app`.
+
+## Get Started
+
+The first-run path is modeled around a local CLI estimate, then GitHub automation:
+
+```powershell
+.\.venv\Scripts\python -m pip install -e .
+cloudcost go
+```
+
+Run `cloudcost go` from a Terraform project directory. It runs the local estimate, then opens the GitHub App manifest install flow with the required webhook, events, and permissions already filled in. If a team only wants the local estimate, `cloudcost` still works by itself. Power users can also run `cloudcost setup`, `cloudcost doctor`, `cloudcost connect-github`, or `cloudcost analyze --plan tfplan.json` directly.
+
+When the package is published, users should install it with:
+
+```bash
+pipx install cloudcost-cli
+cloudcost go
+```
+
+Publishing notes are in `docs/publishing-pypi.md`.
+
+The signed-in dashboard sidebar links to `/get-started`, a docs-style first-run guide with macOS, Windows, and Linux command tabs that update the CLI install, setup, Terraform, CI, and GitHub steps. The left docs rail links to styled HTML docs for CloudCost CLI, VPS install, and pricing API reference.
+
+## Cloudflare Pages Landing Page
+
+For a free public early-access page, deploy the static pages plus the Pages Functions:
+
+- `functions/api/waitlist.js`
+- `functions/api/auth/*`
+- `functions/api/dashboard/summary.js`
+- `package.json`
+
+Use `npm run build` and set the Cloudflare Pages output directory to `dist`; the build script copies `index.html`, `assets/`, `docs/`, `/login`, `/signup`, `/dashboard`, `/get-started`, and `/tester-dashboard`.
+
+Set `DATABASE_URL`, `AUTH_SECRET`, `RESEND_API_KEY`, and `FROM_EMAIL` in Cloudflare Pages environment variables. The Functions store early-access emails, users, OTPs, and browser sessions in Neon, and send Resend confirmations without running the Python backend.
+
+See `docs/cloudflare-pages-waitlist.md`.
+
+## One-Click VPS Path
+
+For a customer-facing install, use the VPS bundle instead of the local debug path.
+
+Prerequisites:
+
+- Ubuntu VPS with ports `80` and `443` open
+- A domain pointed at the VPS
+- Docker, or approval for the bootstrap script to install Docker
+- A pricing mode:
+  - Recommended: CloudCost hosted pricing key
+  - Advanced: Infracost API key for syncing a self-hosted pricing database
+
+Run:
+
+```bash
+git clone YOUR_REPO_URL cloudcost-ai
+cd cloudcost-ai
+bash scripts/bootstrap-vps.sh
+```
+
+The script generates local secrets, creates `.env`, starts Caddy HTTPS, backend, LiteLLM, and Postgres. If the customer chooses strict self-hosted pricing, it also initializes and runs the local Infracost pricing API. It then prints:
+
+- Dashboard: `https://YOUR_DOMAIN/dashboard`
+- Tester runbook: `https://YOUR_DOMAIN/tester-dashboard`
+- GitHub install page: `https://YOUR_DOMAIN/install/github`
+- Webhook URL: `https://YOUR_DOMAIN/api/github/webhook`
+
+Open the GitHub install page and click **Install on GitHub**. GitHub creates a customer-owned GitHub App from CloudCost's manifest and redirects back with the App ID, webhook secret, and private key. CloudCost stores those on the VPS automatically.
+
+After setup, run:
+
+```bash
+bash scripts/doctor-vps.sh
+```
+
+This path is the intended customer install path. The longer local setup below remains for development and debugging.
+
+## Architecture
+
+```text
+Browser
+  -> FastAPI backend
+     -> static landing page
+     -> waitlist endpoint
+     -> GitHub webhook endpoint
+     -> LiteLLM admin wrapper
+     -> metadata-only usage ingest
+
+LLM clients
+  -> LiteLLM proxy :4000
+     -> OpenAI / Anthropic / other providers
+     -> metadata-only callback
+     -> FastAPI /api/llm/usage
+
+GitHub pull_request webhook
+  -> HMAC validation
+  -> installation access token
+  -> locate Terraform plan JSON
+  -> Infracost Plan JSON API
+  -> upsert PR comment
+```
+
+## Quick Start
+
+1. Create local environment config:
+
+```powershell
+Copy-Item .env.example .env
+```
+
+2. Fill `.env` with:
+
+- `DATABASE_URL`, preferably a pooled Neon Postgres URL with `sslmode=require`
+- `GITHUB_APP_ID` or `GITHUB_CLIENT_ID`
+- `GITHUB_PRIVATE_KEY_PATH`
+- `GITHUB_WEBHOOK_SECRET`
+- `INFRACOST_API_KEY`
+- `LITELLM_MASTER_KEY`
+- at least one provider key, such as `OPENAI_API_KEY`
+
+Put the downloaded GitHub App private key at `secrets/github-app-private-key.pem`.
+Docker Compose mounts `./secrets` into the backend container as `/app/secrets`.
+
+`DATABASE_URL` is shared by LiteLLM and the backend. LiteLLM uses it for virtual keys and spend/auth state; the backend creates `cloudcost_waitlist`, `cloudcost_usage_events`, `cloudcost_users`, `cloudcost_email_otps`, and `cloudcost_sessions` tables for app data. Set `APP_DATABASE_URL` if you want those app tables in a separate database.
+
+The waitlist endpoint accepts only an email address, stores one row per email, and uses `data/waitlist.jsonl` only when no Postgres URL is configured. Set `SMTP_HOST` and `SMTP_FROM_EMAIL` if you want waitlist signups to receive a confirmation email.
+
+For app signups, set `AUTH_SECRET` to a long random value. New accounts verify a mail OTP before `/dashboard` creates a session.
+
+3. Start the stack:
+
+```powershell
+docker compose up --build
+```
+
+If Docker Desktop is not installed, run the backend and LiteLLM locally instead:
+
+```powershell
+.\.venv\Scripts\python -m pip install -e ".[dev]"
+.\.venv\Scripts\python -m pip install "litellm[proxy]" prisma
+.\scripts\start-litellm-local.ps1
+```
+
+In a second terminal:
+
+```powershell
+.\.venv\Scripts\python -m uvicorn backend.app.main:app --reload --port 8000
+```
+
+For the local no-Docker path, set `LITELLM_BASE_URL=http://127.0.0.1:4000` in `.env`.
+
+4. Open:
+
+- Landing page: `http://localhost:8000`
+- Sign in: `http://localhost:8000/login`
+- Sign up: `http://localhost:8000/signup`
+- Dashboard: `http://localhost:8000/dashboard`
+- Get started: `http://localhost:8000/get-started`
+- Tester runbook: `http://localhost:8000/tester-dashboard`
+- Backend health: `http://localhost:8000/healthz`
+- Mechanism map: `http://localhost:8000/api/mechanism`
+- LiteLLM proxy: `http://localhost:4000`
+
+## GitHub App Setup
+
+Register a GitHub App with:
+
+- Webhook URL: `https://YOUR_DOMAIN/api/github/webhook`
+- Webhook secret: same value as `GITHUB_WEBHOOK_SECRET`
+- Subscribe to only `pull_request`
+- Repository permissions:
+  - Contents: read
+  - Pull requests: read and write
+  - Issues: write
+  - Metadata: read
+
+The backend handles `opened`, `reopened`, `synchronize`, and `ready_for_review` pull request actions.
+
+## Terraform Plan JSON
+
+The MVP looks for one of these files in the pull request files first, then in the repository tree at the PR head SHA:
+
+- `plan.json`
+- `tfplan.json`
+- `terraform-plan.json`
+- `infracost-plan.json`
+- files ending in `.tfplan.json` or `.plan.json`
+
+Generate a compatible file with Terraform:
+
+```powershell
+terraform init
+terraform plan -out tfplan.binary
+terraform show -json tfplan.binary > plan.json
+```
+
+When found, the backend runs the local Infracost CLI against the plan JSON, parses `diffTotalMonthlyCost`, and creates or updates one CloudCost AI pull request comment. In the default self-hosted setup, the plan JSON stays inside your backend runtime; the CLI only talks to your Cloud Pricing API for price lookups.
+
+## Self-Hosted Infracost
+
+The default project mode is:
+
+```env
+INFRACOST_MODE=cli
+INFRACOST_CLI_PATH=infracost
+INFRACOST_PRICING_API_ENDPOINT=http://127.0.0.1:4001
+```
+
+That means CloudCost AI does not call the hosted Infracost Plan JSON API. Instead:
+
+1. You self-host the Infracost Cloud Pricing API.
+2. The backend runs `infracost breakdown --path plan.json --format json`.
+3. The Infracost CLI requests prices from `INFRACOST_PRICING_API_ENDPOINT`.
+4. The backend comments the result on the pull request.
+
+For local Windows development, install the Infracost CLI and make sure `infracost` is on PATH. For Docker builds, the backend image installs the CLI automatically.
+
+See `/docs/pricing-api.html` for the full setup path.
+
+## LiteLLM Spend Proxy
+
+LiteLLM requires `DATABASE_URL` for persistent virtual keys, budgets, spend logs, and auth state. With Neon, use the pooled connection string from the Neon dashboard:
+
+```env
+DATABASE_URL=postgresql://USER:PASSWORD@HOST/neondb?sslmode=require&channel_binding=require
+```
+
+Create a virtual key through CloudCost AI:
+
+```powershell
+Invoke-RestMethod -Method Post http://localhost:8000/api/llm/keys `
+  -ContentType 'application/json' `
+  -Body '{
+    "user_id": "ada@example.com",
+    "team_id": "platform",
+    "models": ["gpt-5-mini"],
+    "max_budget": 10,
+    "budget_duration": "30d",
+    "metadata": {"service": "billing"}
+  }'
+```
+
+Use the returned key against LiteLLM:
+
+```powershell
+$env:OPENAI_API_KEY = "sk-returned-virtual-key"
+```
+
+Point OpenAI-compatible clients at:
+
+```text
+http://localhost:4000/v1
+```
+
+On the VPS bundle, Caddy exposes LiteLLM through the same HTTPS origin:
+
+```text
+https://YOUR_DOMAIN/llm/v1
+```
+
+LiteLLM enforces the budgets and forwards metadata-only usage records to `/api/llm/usage`. The custom callback deliberately omits prompts, messages, responses, choices, and completions.
+
+## Local Development
+
+Install dependencies:
+
+```powershell
+python -m venv .venv
+.\.venv\Scripts\Activate.ps1
+python -m pip install -e ".[dev]"
+```
+
+Run tests:
+
+```powershell
+pytest
+```
+
+Run the backend without Docker:
+
+```powershell
+uvicorn backend.app.main:app --reload --port 8000
+```
+
+## Important Limits
+
+This is an MVP scaffold, not a production billing system yet.
+
+- Real GitHub, Infracost, and LLM provider credentials are required for end-to-end live calls.
+- The JSONL stores in `data/` are for local validation; replace them with a database before production.
+- For production GitHub traffic, put the backend behind HTTPS and keep the webhook secret/private key out of the repo.
+- For production LiteLLM, pin image versions, rotate master keys, and use a managed Postgres database.

cloudcost_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+backend/__init__.py,sha256=N0SwZfj8doy0rALL59GNmGD2Mv_0oqS7C2Jb6MeZLdM,36
+backend/app/__init__.py,sha256=WXhIwhrL14NlB8bjQG6RO3IM5HcX7JgOsxiGnwUnJ0E,44
+backend/app/auth.py,sha256=Lb7tJwz40fKeWbfMS472nNhG-NOjjs82Ps_Va4I4veM,3074
+backend/app/cli.py,sha256=uivTSbFj4q6rem5oUpvLDDuxBaoUNMsaP62oszaUCFQ,25830
+backend/app/comments.py,sha256=sbynhhu4tGNgTIQpdRtWe8puh8sF4Ca5VnvPnO7_XQA,3004
+backend/app/config.py,sha256=px2d0OQduvniWcnGUtTZ8LOb26KnkAVbCjQRsk2aIE4,7027
+backend/app/database.py,sha256=qk-gCUye5rcng5qmNGH99Yx6b9Lak1kpBu3iR5MdczE,16083
+backend/app/emailer.py,sha256=GmJ3aaHaH_oMdw_4LwPykopjaeEj3cXB_nK0ULEvILI,5713
+backend/app/github_client.py,sha256=rf52xIorJYJuKToXbwZwem7zCW0rHCIi8rWFZHzKL0Q,7622
+backend/app/infracost.py,sha256=87EFZEuAIJE6FWxoM_XqKotpuQymz_36m6IiQ6YDP5w,5143
+backend/app/litellm_admin.py,sha256=w0NAi4q6IoNTRACSQUonYkwypvvymORaSWy4sJRxHV8,1327
+backend/app/main.py,sha256=5YSlocT1aRG8mEcoPDfm-b-wd8YcJaIVmmrx_L51fOM,38538
+backend/app/model_pricing.py,sha256=ENnaGg9VjYNaeWKmHE0QhOPEG88jznLBN-6bA408MXw,3187
+backend/app/security.py,sha256=tXDGKvOpTiDVi-Lz6KLqiwFzx2W1KH_Yv4UKYEP0FxI,420
+backend/app/storage.py,sha256=pMGrpuuDP0K8SfSEl5DorkXKmtDHFT5SS5mkgKg7le8,898
+backend/app/usage.py,sha256=wCC5t73Jte_glefomRIHRf5w4jyVhe1vd4NB4XUGWMo,2090
+cloudcost_cli-0.1.0.dist-info/METADATA,sha256=VSMcyIKoZq98-H5wvz-IOptjRP3VgUIowMXMMDij5Cs,12304
+cloudcost_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+cloudcost_cli-0.1.0.dist-info/entry_points.txt,sha256=lp30NDXoctR8I-f6Z-rorAEgyKR26j-aJVLfHNWLoa0,51
+cloudcost_cli-0.1.0.dist-info/top_level.txt,sha256=o0r_qMzzBDDtK9APrv2QVcIw9oc00JRmCEsTE2-AFr0,8
+cloudcost_cli-0.1.0.dist-info/RECORD,,

cloudcost_cli-0.1.0.dist-info/WHEEL

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

cloudcost_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cloudcost = backend.app.cli:main

cloudcost_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+backend