hevn-cli 0.1.0__py3-none-any.whl

hevn_cli/__init__.py

@@ -0,0 +1,8 @@
+"""HEVN CLI package."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("hevn-cli")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

hevn_cli/api/__init__.py

@@ -0,0 +1,6 @@
+from hevn_cli.api.app import AppApi
+from hevn_cli.api.base import ApiClient, AuthMode
+from hevn_cli.api.mcp import McpApi
+from hevn_cli.api.public import PublicApi
+
+__all__ = ["ApiClient", "AppApi", "AuthMode", "McpApi", "PublicApi"]

hevn_cli/api/app.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from typing import Any
+
+from hevn_cli.api.base import ApiClient, AuthMode
+
+
+class AppApi:
+    def __init__(self, client: ApiClient | None = None) -> None:
+        self.client = client or ApiClient(AuthMode.APP)
+
+    def current_user(self) -> dict[str, Any]:
+        return self.client.get("/user")
+
+    def update_profile(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.put("/user/kyc", json=payload)
+
+    def kyc_link(self) -> dict[str, Any]:
+        return self.client.post("/user/kyc_link")
+
+    def kyc_status(self, *, provider: str = "swipelux") -> dict[str, Any]:
+        return self.client.get("/user/kyc/status", params={"provider": provider})
+
+    def balance(self) -> dict[str, Any]:
+        return self.client.get("/balance")
+
+    def list_contacts(self, *, limit: int = 100, offset: int = 0) -> dict[str, Any]:
+        return self.client.get("/user/contacts", params={"limit": limit, "offset": offset})
+
+    def list_transactions(
+        self,
+        *,
+        limit: int = 50,
+        offset: int = 0,
+        transaction_type: str | None = None,
+        status: str | None = None,
+        income_only: bool | None = None,
+        bank_account_id: str | None = None,
+    ) -> dict[str, Any]:
+        return self.client.get(
+            "/transactions",
+            params={
+                "limit": limit,
+                "offset": offset,
+                "type": transaction_type,
+                "status": status,
+                "incomeOnly": income_only,
+                "bankAccountId": bank_account_id,
+            },
+        )
+
+    def create_contact(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.post("/user/contact", json=payload)
+
+    def update_contact(self, contact_id: str, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.patch(f"/user/contacts/{contact_id}", json=payload)
+
+    def delete_contact(self, contact_id: str) -> Any:
+        return self.client.delete(f"/user/contacts/{contact_id}")
+
+    def upload_document(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.post("/documents/upload", json=payload)
+
+    def list_invoices(self) -> dict[str, Any]:
+        return self.client.get("/documents/contracts/invoices")
+
+    def get_invoice(self, invoice_id: str) -> dict[str, Any]:
+        return self.client.get(f"/documents/contracts/invoices/{invoice_id}")
+
+    def create_invoice(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.post("/documents/contracts/invoices", json=payload)
+
+    def create_uploaded_invoice(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.post("/documents/contracts/invoices/uploaded", json=payload)
+
+    def update_invoice(self, invoice_id: str, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.put(f"/documents/contracts/invoices/{invoice_id}", json=payload)
+
+    def create_invoice_from_contract(self, contract_id: str, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.post(f"/documents/contracts/{contract_id}/create-invoice", json=payload)
+
+    def batch_invoicing(self, payload: list[dict[str, Any]]) -> dict[str, Any]:
+        return self.client.post("/documents/contracts/invoices/batch_invoicing", json=payload)
+
+    def list_contracts(self) -> dict[str, Any]:
+        return self.client.get("/documents/contracts")
+
+    def get_contract(self, contract_id: str) -> dict[str, Any]:
+        return self.client.get(f"/documents/contracts/{contract_id}")
+
+    def preview_contract(self, contract_id: str) -> dict[str, Any]:
+        return self.client.get(f"/documents/contracts/{contract_id}/preview")
+
+    def create_contract(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.post("/documents/contracts", json=payload)
+
+    def pause_contract(self, contract_id: str) -> dict[str, Any]:
+        return self.client.post(f"/documents/contracts/{contract_id}/pause")
+
+    def approve_contract(self, contract_id: str) -> dict[str, Any]:
+        return self.client.post(f"/documents/contracts/{contract_id}/approve")
+
+    def update_contract_payment_methods(
+        self, contract_id: str, payment_methods: list[dict[str, Any]]
+    ) -> dict[str, Any]:
+        return self.client.put(
+            f"/documents/contracts/{contract_id}/payment_methods",
+            json={"paymentMethods": payment_methods},
+        )
+
+    def delete_contract(self, contract_id: str) -> dict[str, Any]:
+        return self.client.delete(f"/documents/contracts/{contract_id}")
+
+    def list_banks(self) -> dict[str, Any]:
+        return self.client.get("/banks")
+
+    def activate_banks(self, rails: list[str]) -> dict[str, Any]:
+        return self.client.post("/banks/activate", json={"rails": rails})
+
+    def validate_bank(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.post("/user/contact/bank/validate", json=payload)
+
+    def payin_quote(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.post("/balance/payin/quote", json=payload)
+
+    def bank_payin_quote(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.post("/banks/payin/quote", json=payload)
+
+    def submit_bank_payin_quote(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.post("/banks/payin/quote/submit", json=payload)
+
+    def payout_quote(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.post("/balance/payout/quote", json=payload)
+
+    def list_cards(self) -> dict[str, Any]:
+        return self.client.get("/cards")
+
+    def create_card(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.post("/cards", json=payload)
+
+    def get_card(self, card_id: str) -> dict[str, Any]:
+        return self.client.get(f"/cards/{card_id}")
+
+    def card_details(self, card_id: str, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.post(f"/cards/{card_id}/details", json=payload)
+
+    def update_card_label(self, card_id: str, label: str) -> dict[str, Any]:
+        return self.client.put(f"/cards/{card_id}/label", json={"label": label})
+
+    def update_card_limit(self, card_id: str, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.client.put(f"/cards/{card_id}/limit", json=payload)
+
+    def freeze_card(self, card_id: str) -> Any:
+        return self.client.post(f"/cards/{card_id}/freeze")
+
+    def unfreeze_card(self, card_id: str) -> Any:
+        return self.client.post(f"/cards/{card_id}/unfreeze")
+
+    def card_kyc_link(self) -> dict[str, Any]:
+        return self.client.post("/cards/kyc/link")
+
+    def pre_approve_cards(self) -> dict[str, Any]:
+        return self.client.post("/cards/pre-approve")

hevn_cli/api/base.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any
+
+from hevn_cli.client import app_headers, mcp_headers, request
+
+
+class AuthMode(str, Enum):
+    APP = "app"
+    MCP = "mcp"
+    PUBLIC = "public"
+
+
+class ApiClient:
+    def __init__(self, auth_mode: AuthMode, *, idempotency_key: str | None = None) -> None:
+        self.auth_mode = auth_mode
+        self.idempotency_key = idempotency_key
+
+    def _headers(self) -> dict[str, str]:
+        if self.auth_mode == AuthMode.APP:
+            return app_headers()
+        if self.auth_mode == AuthMode.MCP:
+            return mcp_headers(self.idempotency_key)
+        return {"Accept": "application/json"}
+
+    def get(self, path: str, *, params: dict[str, Any] | None = None) -> Any:
+        return request("GET", path, headers=self._headers(), params=params)
+
+    def post(self, path: str, *, json: dict[str, Any] | None = None) -> Any:
+        return request("POST", path, headers=self._headers(), json_body=json)
+
+    def put(self, path: str, *, json: dict[str, Any] | None = None) -> Any:
+        return request("PUT", path, headers=self._headers(), json_body=json)
+
+    def patch(self, path: str, *, json: dict[str, Any] | None = None) -> Any:
+        return request("PATCH", path, headers=self._headers(), json_body=json)
+
+    def delete(self, path: str) -> Any:
+        return request("DELETE", path, headers=self._headers())

hevn_cli/api/mcp.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import Any
+
+from hevn_cli.api.base import ApiClient, AuthMode
+
+
+class McpApi:
+    def __init__(self, *, idempotency_key: str | None = None, client: ApiClient | None = None) -> None:
+        self.client = client or ApiClient(AuthMode.MCP, idempotency_key=idempotency_key)
+
+    def balance(self) -> dict[str, Any]:
+        return self.client.get("/mcp/get_balance")
+
+    def transfer(
+        self,
+        data: dict[str, Any] | None = None,
+        *,
+        contact_id: str | None = None,
+        invoice_id: str | None = None,
+        quote_id: str | None = None,
+        amount: float | None = None,
+        memo: str | None = None,
+    ) -> dict[str, Any]:
+        body = dict(data or {})
+        if contact_id:
+            body["contactId"] = contact_id
+        if invoice_id:
+            body["invoiceId"] = invoice_id
+        if quote_id:
+            body["quoteId"] = quote_id
+        if amount is not None:
+            body["amount"] = amount
+        if memo:
+            body["memo"] = memo
+        if not (body.get("contactId") or body.get("invoiceId") or body.get("quoteId")):
+            raise ValueError("MCP transfer requires contact_id, invoice_id, or quote_id.")
+        return self.client.post("/mcp/transfer", json=body)
+
+    def transfers(
+        self,
+        *,
+        limit: int = 50,
+        offset: int = 0,
+        idempotency_key: str | None = None,
+    ) -> dict[str, Any]:
+        return self.client.get(
+            "/mcp/transfers",
+            params={"limit": limit, "offset": offset, "idempotency_key": idempotency_key},
+        )

hevn_cli/api/public.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Any
+
+from hevn_cli.api.base import ApiClient, AuthMode
+
+
+class PublicApi:
+    def __init__(self, client: ApiClient | None = None) -> None:
+        self.client = client or ApiClient(AuthMode.PUBLIC)
+
+    def rate(self, currency: str) -> dict[str, Any]:
+        return self.client.get(f"/utils/rates/{currency}")
+
+    def invoice(self, invoice_id: str) -> dict[str, Any]:
+        return self.client.get(f"/public/invoices/{invoice_id}")

hevn_cli/client.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+
+from hevn_cli.config import get_config_value
+from hevn_cli.env import api_url
+from hevn_cli.progress import waiting
+
+DEFAULT_BASE_URL = "https://api.hevn.finance/api/v1"
+
+
+class HevnError(RuntimeError):
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int | None = None,
+        reason: str | None = None,
+        detail: Any | None = None,
+        method: str | None = None,
+        url: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.reason = reason
+        self.detail = detail
+        self.method = method
+        self.url = url
+
+
+def base_url() -> str:
+    try:
+        raw = api_url()
+    except ValueError as exc:
+        raise HevnError(str(exc)) from exc
+    parsed = urlparse(raw)
+    if parsed.scheme and parsed.netloc:
+        docs_paths = {"/docs", "/redoc", "/openapi.json"}
+        api_docs_paths = {f"/api/v1{path}" for path in docs_paths}
+        path = parsed.path.rstrip("/")
+        if path in docs_paths:
+            return f"{parsed.scheme}://{parsed.netloc}/api/v1"
+        if path in api_docs_paths:
+            return f"{parsed.scheme}://{parsed.netloc}/api/v1"
+    if parsed.scheme and parsed.netloc and parsed.path in ("", "/"):
+        return f"{raw}/api/v1"
+    return raw
+
+
+def app_headers() -> dict[str, str]:
+    key = os.getenv("HEVN_API_KEY") or get_config_value("api_key")
+    if not key:
+        raise HevnError("This command needs app authorization (JWT). Run `hevn login` first or set HEVN_API_KEY.")
+    header = os.getenv("HEVN_API_KEY_HEADER", "Authorization")
+    if header.lower() == "authorization" and not key.lower().startswith("bearer "):
+        key = f"Bearer {key}"
+    return {
+        header: key,
+        "Accept": "application/json",
+        "device-id": os.getenv("HEVN_DEVICE_ID") or get_config_value("device_id") or "hevn-cli",
+        "device-type": "cli",
+        "device-name": "HEVN CLI",
+    }
+
+
+def mcp_headers(idempotency_key: str | None = None) -> dict[str, str]:
+    key = os.getenv("HEVN_MCP_KEY") or get_config_value("mcp_key")
+    if not key:
+        raise HevnError("This command needs an MCP key. Run `hevn login` first or set HEVN_MCP_KEY.")
+    headers = {"X-API-Key": key, "Accept": "application/json"}
+    if idempotency_key:
+        headers["Idempotency-Key"] = idempotency_key
+    return headers
+
+
+def request(
+    method: str,
+    path: str,
+    *,
+    headers: dict[str, str],
+    json_body: dict[str, Any] | None = None,
+    params: dict[str, Any] | None = None,
+) -> Any:
+    url = f"{base_url()}{path}"
+    try:
+        with waiting(f"Waiting for HEVN {method} {path}"):
+            with httpx.Client(timeout=60) as client:
+                response = client.request(
+                    method,
+                    url,
+                    headers=headers,
+                    json=json_body,
+                    params={k: v for k, v in (params or {}).items() if v is not None},
+                )
+    except httpx.HTTPError as exc:
+        raise HevnError(f"Request failed: {exc}", method=method, url=url) from exc
+
+    if response.status_code >= 400:
+        try:
+            detail: Any = response.json()
+        except ValueError:
+            detail = response.text
+        message = detail.get("detail") if isinstance(detail, dict) else detail
+        if isinstance(message, dict):
+            message = message.get("detail") or message.get("message") or str(message)
+        if not isinstance(message, str):
+            message = str(message)
+        raise HevnError(
+            message,
+            status_code=response.status_code,
+            reason=response.reason_phrase,
+            detail=detail,
+            method=method,
+            url=str(response.request.url),
+        )
+    if not response.content:
+        return None
+    return response.json()

hevn_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command groups."""