o2-cli 0.1.0__py3-none-any.whl

o2_cli/__init__.py

@@ -0,0 +1,30 @@
+"""O2 CLI - Command-line interface for O2 DEX Trading Platform."""
+
+from pathlib import Path
+
+__version__ = "0.1.0"
+
+
+def ensure_skill_installed() -> bool:
+    """自动安装 Claude Code Skill 到 ~/.claude/skills/o2-cli/。
+
+    首次运行 o2 命令时检查并安装。不覆盖已有文件（用户可能自定义过）。
+
+    Returns:
+        True 如果 skill 已存在或刚安装成功，False 如果安装失败。
+    """
+    skill_dir = Path.home() / ".claude" / "skills" / "o2-cli"
+    skill_file = skill_dir / "SKILL.md"
+
+    if skill_file.exists():
+        return True
+
+    try:
+        from o2_cli.setup import SKILL_CONTENT
+
+        skill_dir.mkdir(parents=True, exist_ok=True)
+        skill_file.write_text(SKILL_CONTENT, encoding="utf-8")
+        return True
+    except OSError:
+        # 权限不足或其他 IO 错误，静默失败不影响 CLI 使用
+        return False

o2_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Support `python -m o2_cli`."""
+
+from o2_cli.cli import app
+
+if __name__ == "__main__":
+    app()

o2_cli/cli.py

@@ -0,0 +1,94 @@
+"""O2 CLI root - Typer application with global options."""
+
+import asyncio
+import typing as t
+from typing import Optional
+
+import typer
+
+from o2_cli import __version__, ensure_skill_installed
+
+app = typer.Typer(
+    name="o2",
+    help="O2 DEX Trading Platform CLI",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+
+def version_callback(value: bool):
+    if value:
+        typer.echo(f"o2-cli version {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    json_output: bool = typer.Option(False, "--json", help="Output raw JSON"),
+    config: Optional[str] = typer.Option(None, "--config", help="Config file path"),
+    profile: Optional[str] = typer.Option(None, "--profile", help="Config profile"),
+    api_url: Optional[str] = typer.Option(None, "--api-url", help="Override API URL"),
+    timeout: float = typer.Option(30.0, "--timeout", help="HTTP timeout in seconds"),
+    verbose: bool = typer.Option(False, "-v", "--verbose", help="Verbose logging"),
+    version: bool = typer.Option(False, "--version", callback=version_callback, is_eager=True),
+):
+    """O2 DEX Trading Platform CLI."""
+    # Auto-install Claude Code skill on first run
+    ensure_skill_installed()
+    # Store global state for commands to access
+    app.state = {
+        "json_output": json_output,
+        "config_path": config,
+        "profile": profile,
+        "api_url": api_url,
+        "timeout": timeout,
+        "verbose": verbose,
+    }
+
+
+def get_state() -> dict:
+    """Get global CLI state."""
+    return getattr(app, "state", {
+        "json_output": False,
+        "config_path": None,
+        "profile": None,
+        "api_url": None,
+        "timeout": 30.0,
+        "verbose": False,
+    })
+
+
+# Register command groups
+from o2_cli.commands import (  # noqa: E402
+    auth,
+    balance,
+    orders,
+    positions,
+    markets,
+    trades,
+    fees,
+    deposits,
+    withdrawals,
+    settings,
+    notifications,
+    account,
+    admin,
+    mm,
+    setup_cmd,
+)
+
+app.add_typer(auth.app, name="auth", help="Authentication")
+app.add_typer(balance.app, name="balance", help="Balance queries")
+app.add_typer(orders.app, name="orders", help="Order management")
+app.add_typer(positions.app, name="positions", help="Position management")
+app.add_typer(markets.app, name="markets", help="Market data")
+app.add_typer(trades.app, name="trades", help="Trade history")
+app.add_typer(fees.app, name="fees", help="Fee information")
+app.add_typer(deposits.app, name="deposits", help="Deposit management")
+app.add_typer(withdrawals.app, name="withdrawals", help="Withdrawal management")
+app.add_typer(settings.app, name="settings", help="User settings")
+app.add_typer(notifications.app, name="notifications", help="Notifications")
+app.add_typer(account.app, name="account", help="Account overview")
+app.add_typer(admin.app, name="admin", help="Admin operations")
+app.add_typer(mm.app, name="mm", help="Market maker control")
+app.add_typer(setup_cmd.app, name="setup", help="Setup for vibe coding tools")

o2_cli/client.py

@@ -0,0 +1,307 @@
+"""Async httpx API client for O2 Backend.
+
+All HTTP calls flow through this single class.
+Automatically injects auth headers (JWT or API Key).
+Handles O2Response envelope: {success, data, error, code, timestamp}.
+"""
+
+from typing import Any, Optional
+
+import httpx
+
+from o2_cli.exceptions import APIError, ConnectionError
+
+
+class O2Client:
+    """Async HTTP client for O2 Backend API."""
+
+    def __init__(self, base_url: str, timeout: float = 30.0):
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._token: Optional[str] = None
+        self._api_key_id: Optional[str] = None
+        self._api_secret: Optional[str] = None
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def __aenter__(self) -> "O2Client":
+        self._client = httpx.AsyncClient(
+            base_url=self._base_url,
+            timeout=self._timeout,
+        )
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    def set_jwt(self, token: str) -> None:
+        self._token = token
+
+    def set_api_key(self, key_id: str, secret: str) -> None:
+        self._api_key_id = key_id
+        self._api_secret = secret
+
+    def _build_headers(self) -> dict[str, str]:
+        headers: dict[str, str] = {"Content-Type": "application/json"}
+        if self._token:
+            headers["Authorization"] = f"Bearer {self._token}"
+        if self._api_key_id and self._api_secret:
+            headers["X-API-Key-ID"] = self._api_key_id
+            headers["X-API-Secret"] = self._api_secret
+        return headers
+
+    async def _request(self, method: str, path: str, **kwargs) -> dict[str, Any]:
+        """Core request method. Handles O2Response envelope."""
+        if not self._client:
+            raise RuntimeError("Client not initialized. Use 'async with O2Client(...)'")
+
+        try:
+            response = await self._client.request(
+                method, path, headers=self._build_headers(), **kwargs
+            )
+        except httpx.ConnectError as e:
+            raise ConnectionError(
+                f"Cannot connect to {self._base_url}. Is the O2 backend running?"
+            ) from e
+        except httpx.TimeoutException as e:
+            raise ConnectionError(
+                f"Request timed out after {self._timeout}s. Try --timeout 60."
+            ) from e
+        except httpx.HTTPError as e:
+            raise ConnectionError(f"Request failed: {e}") from e
+
+        # Parse response
+        try:
+            body = response.json()
+        except Exception:
+            if response.status_code >= 400:
+                raise APIError(response.status_code, response.text)
+            return {"data": response.text}
+
+        # Handle O2Response envelope
+        if isinstance(body, dict):
+            if "success" in body:
+                if not body["success"]:
+                    error_msg = body.get("error") or body.get("message") or "Unknown error"
+                    error_code = body.get("code")
+                    raise APIError(response.status_code, error_msg, error_code)
+                data = body.get("data")
+                return data if data is not None else body
+            # Some endpoints return raw dicts without envelope
+            return body
+
+        return {"data": body}
+
+    async def get(self, path: str, params: dict | None = None) -> dict[str, Any]:
+        return await self._request("GET", path, params=params)
+
+    async def post(self, path: str, json: dict | None = None) -> dict[str, Any]:
+        return await self._request("POST", path, json=json or {})
+
+    async def put(self, path: str, json: dict | None = None) -> dict[str, Any]:
+        return await self._request("PUT", path, json=json or {})
+
+    async def delete(self, path: str) -> dict[str, Any]:
+        return await self._request("DELETE", path)
+
+    # ── Auth ──────────────────────────────────────────────
+
+    async def auth_challenge(self, wallet_address: str) -> dict:
+        return await self.post("/auth/challenge", {"wallet_address": wallet_address})
+
+    async def auth_signature_login(
+        self, wallet_address: str, signature: str, message: str
+    ) -> dict:
+        return await self.post(
+            "/auth/signature-login",
+            {
+                "wallet_address": wallet_address,
+                "signature": signature,
+                "message": message,
+            },
+        )
+
+    async def auth_test_login(self) -> dict:
+        return await self.post("/auth/test-login")
+
+    async def auth_me(self) -> dict:
+        return await self.get("/auth/me")
+
+    async def auth_session_status(self) -> dict:
+        return await self.get("/auth/session-status")
+
+    async def auth_refresh(self, token: str) -> dict:
+        self._token = token
+        return await self.post("/auth/refresh")
+
+    # ── Balance ───────────────────────────────────────────
+
+    async def get_balance(self) -> dict:
+        return await self.get("/balance")
+
+    async def get_balance_history(self, limit: int = 50, offset: int = 0) -> dict:
+        return await self.get("/balance/history", {"limit": limit, "offset": offset})
+
+    # ── Orders ────────────────────────────────────────────
+
+    async def create_order(self, **kwargs) -> dict:
+        return await self.post("/orders", kwargs)
+
+    async def list_orders(
+        self, market_id: int | None = None, status_filter: str | None = None
+    ) -> dict:
+        params = {}
+        if market_id is not None:
+            params["market_id"] = market_id
+        if status_filter:
+            params["status_filter"] = status_filter
+        return await self.get("/orders", params or None)
+
+    async def cancel_order(self, order_id: str) -> dict:
+        return await self.post("/orders/cancel", {"order_id": order_id})
+
+    async def cancel_all_orders(self, market_id: int | None = None) -> dict:
+        payload = {}
+        if market_id is not None:
+            payload["market_id"] = market_id
+        return await self.post("/orders/cancel-all", payload)
+
+    async def modify_order(self, order_id: str, **kwargs) -> dict:
+        kwargs["order_id"] = order_id
+        return await self.post("/orders/modify", kwargs)
+
+    async def batch_orders(self, operations: list) -> dict:
+        return await self.post("/orders/batch", {"operations": operations})
+
+    # ── Positions ─────────────────────────────────────────
+
+    async def get_positions(self) -> dict:
+        return await self.get("/positions")
+
+    async def get_position_by_market(self, market_id: int) -> dict:
+        return await self.get(f"/positions/market/{market_id}")
+
+    async def close_position(self, position_id: str) -> dict:
+        return await self.post(f"/positions/close/{position_id}")
+
+    async def get_liquidation_risk(self, market_id: int) -> dict:
+        return await self.get(f"/positions/liquidation-risk/{market_id}")
+
+    # ── Markets ───────────────────────────────────────────
+
+    async def get_markets(self) -> dict:
+        return await self.get("/markets")
+
+    async def get_orderbook(self, market_id: int) -> dict:
+        return await self.get(f"/markets/{market_id}/orderbook")
+
+    async def get_market_trades(self, market_id: int, limit: int = 50) -> dict:
+        return await self.get(f"/markets/{market_id}/trades", {"limit": limit})
+
+    async def get_candles(
+        self, market_id: int, interval: str = "1h", limit: int = 500
+    ) -> dict:
+        return await self.get(
+            f"/markets/{market_id}/candles", {"interval": interval, "limit": limit}
+        )
+
+    # ── Trades ────────────────────────────────────────────
+
+    async def get_trades(
+        self, skip: int = 0, limit: int = 50, market_id: int | None = None
+    ) -> dict:
+        params = {"skip": skip, "limit": limit}
+        if market_id is not None:
+            params["market_id"] = market_id
+        return await self.get("/trades", params)
+
+    async def get_trade_summary(self) -> dict:
+        return await self.get("/trades/summary")
+
+    # ── Fees ──────────────────────────────────────────────
+
+    async def get_fee_rates(self) -> dict:
+        return await self.get("/fees/rates")
+
+    async def estimate_fee(self, base_amount: str, price: str, is_maker: bool = False) -> dict:
+        return await self.post(
+            "/fees/estimate",
+            {"base_amount": base_amount, "price": price, "is_maker": is_maker},
+        )
+
+    # ── Deposits ──────────────────────────────────────────
+
+    async def get_deposit_address(self, chain: str = "base") -> dict:
+        return await self.get("/deposits/address", {"chain": chain})
+
+    async def get_deposit_history(self, limit: int = 50) -> dict:
+        return await self.get("/deposits/history", {"limit": limit})
+
+    # ── Withdrawals ───────────────────────────────────────
+
+    async def create_withdrawal(
+        self, amount: str, address: str, chain: str = "ethereum", currency: str = "USDC"
+    ) -> dict:
+        return await self.post(
+            "/withdrawals/create",
+            {
+                "amount": amount,
+                "to_address": address,
+                "chain": chain,
+                "currency": currency,
+            },
+        )
+
+    async def get_withdrawal(self, withdrawal_id: str) -> dict:
+        return await self.get(f"/withdrawals/{withdrawal_id}")
+
+    async def cancel_withdrawal(self, withdrawal_id: str) -> dict:
+        return await self.post(f"/withdrawals/{withdrawal_id}/cancel")
+
+    async def get_withdrawal_history(self, limit: int = 20, offset: int = 0) -> dict:
+        return await self.get("/withdrawals", {"limit": limit, "offset": offset})
+
+    # ── Settings ──────────────────────────────────────────
+
+    async def get_user_settings(self) -> dict:
+        return await self.get("/user-settings")
+
+    async def set_leverage(self, market_id: int, leverage: int) -> dict:
+        return await self.post(f"/user-settings/leverage/{market_id}", {"leverage": leverage})
+
+    async def set_margin_mode(self, mode: str) -> dict:
+        return await self.post("/user-settings/margin-mode", {"margin_mode": mode})
+
+    # ── Notifications ─────────────────────────────────────
+
+    async def get_notifications(self, **kwargs) -> dict:
+        return await self.get("/notifications", kwargs or None)
+
+    async def get_unread_count(self) -> dict:
+        return await self.get("/notifications/unread-count")
+
+    async def mark_notification_read(self, notification_id: str) -> dict:
+        return await self.put(f"/notifications/{notification_id}/read")
+
+    # ── Account ───────────────────────────────────────────
+
+    async def get_account_overview(self) -> dict:
+        return await self.get("/account/overview")
+
+    # ── Market Maker ──────────────────────────────────────
+
+    async def mm_status(self) -> dict:
+        return await self.get("/market-maker/status")
+
+    async def mm_start(self) -> dict:
+        return await self.post("/market-maker/start")
+
+    async def mm_stop(self) -> dict:
+        return await self.post("/market-maker/stop")
+
+    async def mm_stats(self) -> dict:
+        return await self.get("/market-maker-stats/overview")
+
+    async def mm_orders(self) -> dict:
+        return await self.get("/market-maker-orders/current")

o2_cli/commands/__init__.py

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

o2_cli/commands/_helpers.py

@@ -0,0 +1,65 @@
+"""Shared helpers for CLI commands to reduce boilerplate."""
+
+import asyncio
+from pathlib import Path
+from functools import wraps
+from typing import Callable, Any
+
+import typer
+
+from o2_cli.cli import get_state
+from o2_cli.client import O2Client
+from o2_cli.config import load_config, get_active_profile, CONFIG_FILE
+from o2_cli.exceptions import APIError, ConnectionError
+from o2_cli.output import OutputFormatter
+
+
+def resolve_context(state: dict | None = None):
+    """Resolve CLI context: config, profile, formatter, api_url, timeout.
+
+    Returns: (profile, formatter, api_url, timeout)
+    """
+    if state is None:
+        state = get_state()
+
+    config_path = Path(state["config_path"]) if state.get("config_path") else CONFIG_FILE
+    config = load_config(config_path)
+    if state.get("profile"):
+        config.active_profile = state["profile"]
+
+    profile = get_active_profile(config)
+    formatter = OutputFormatter(json_mode=state["json_output"])
+    api_url = state.get("api_url") or profile.api_url
+    timeout = state.get("timeout", profile.timeout) or profile.timeout
+
+    return profile, formatter, api_url, timeout
+
+
+def require_auth(profile, formatter) -> bool:
+    """Check if user is authenticated. Returns True if OK, False if not."""
+    if profile.auth_type == "jwt" and not profile.token:
+        formatter.print_error("Not authenticated. Run 'o2 auth test-login' or 'o2 auth login' first.")
+        return False
+    return True
+
+
+def setup_client(client: O2Client, profile):
+    """Configure client auth from profile."""
+    if profile.token:
+        client.set_jwt(profile.token)
+    if profile.api_key_id:
+        client.set_api_key(profile.api_key_id, profile.api_secret)
+
+
+def handle_api_errors(func: Callable) -> Callable:
+    """Decorator for async command handlers that catches API/Connection errors."""
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        try:
+            return await func(*args, **kwargs)
+        except APIError as e:
+            # Need to get formatter from somewhere - callers should handle
+            raise
+        except ConnectionError as e:
+            raise
+    return wrapper

o2_cli/commands/account.py

@@ -0,0 +1,46 @@
+"""o2 account commands - Account overview."""
+
+import asyncio
+
+import typer
+
+from o2_cli.cli import get_state
+from o2_cli.client import O2Client
+from o2_cli.config import load_config, get_active_profile
+from o2_cli.exceptions import APIError, ConnectionError
+from o2_cli.output import OutputFormatter
+
+app = typer.Typer(help="Account overview")
+
+
+@app.command("overview")
+def overview():
+    """Show full account overview (balance, positions, PnL)."""
+    asyncio.run(_overview())
+
+
+async def _overview():
+    state = get_state()
+    formatter = OutputFormatter(json_mode=state["json_output"])
+    config = load_config()
+    profile = get_active_profile(config)
+    api_url = state.get("api_url") or profile.api_url
+    timeout = state.get("timeout") or profile.timeout
+
+    if not profile.token and profile.auth_type == "jwt":
+        formatter.print_error("Not authenticated. Run 'o2 auth test-login' first.")
+        raise typer.Exit(1)
+
+    async with O2Client(api_url, timeout) as client:
+        client.set_jwt(profile.token)
+        if profile.api_key_id:
+            client.set_api_key(profile.api_key_id, profile.api_secret)
+        try:
+            data = await client.get_account_overview()
+            formatter.print_raw(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)