o2-cli 0.1.0__py3-none-any.whl

o2_cli/commands/positions.py

@@ -0,0 +1,158 @@
+"""o2 positions commands - Position management."""
+
+import asyncio
+from typing import Optional
+
+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="Position management")
+
+
+@app.command("list")
+def list_positions():
+    """List all open positions."""
+    asyncio.run(_list_positions())
+
+
+async def _list_positions():
+    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_positions()
+            formatter.print_positions(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)
+
+
+@app.command("market")
+def market(
+    market_id: int = typer.Option(..., "--market-id", "-m", help="Market ID"),
+):
+    """Show position for a specific market."""
+    asyncio.run(_market(market_id))
+
+
+async def _market(market_id: int):
+    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_position_by_market(market_id)
+            formatter.print_positions(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)
+
+
+@app.command("close")
+def close(
+    position_id: str = typer.Option(
+        ..., "--position-id", "-i", help="Position ID to close"
+    ),
+):
+    """Close an open position."""
+    asyncio.run(_close(position_id))
+
+
+async def _close(position_id: str):
+    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.close_position(position_id)
+            formatter.print_raw(data)
+            if not state["json_output"]:
+                formatter.print_success(f"Position {position_id} closed")
+        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)
+
+
+@app.command("risk")
+def risk(
+    market_id: int = typer.Option(
+        ..., "--market-id", "-m", help="Market ID to check liquidation risk"
+    ),
+):
+    """Check liquidation risk for a market position."""
+    asyncio.run(_risk(market_id))
+
+
+async def _risk(market_id: int):
+    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_liquidation_risk(market_id)
+            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)

o2_cli/commands/settings.py

@@ -0,0 +1,129 @@
+"""o2 settings commands - User settings management."""
+
+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="User settings")
+
+
+@app.command("get")
+def get():
+    """Show current user settings."""
+    asyncio.run(_get())
+
+
+async def _get():
+    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_user_settings()
+            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)
+
+
+@app.command("leverage")
+def leverage(
+    market_id: int = typer.Option(..., "--market-id", "-m", help="Market ID"),
+    leverage: int = typer.Option(..., "--leverage", "-l", help="Leverage value"),
+):
+    """Set leverage for a market."""
+    asyncio.run(_leverage(market_id, leverage))
+
+
+async def _leverage(market_id: int, leverage_val: int):
+    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.set_leverage(market_id, leverage_val)
+            formatter.print_raw(data)
+            if not state["json_output"]:
+                formatter.print_success(
+                    f"Leverage set to {leverage_val}x for market {market_id}"
+                )
+        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)
+
+
+@app.command("margin-mode")
+def margin_mode(
+    mode: str = typer.Option(
+        ..., "--mode", "-m", help="Margin mode (cross/isolated)"
+    ),
+):
+    """Set global margin mode."""
+    asyncio.run(_margin_mode(mode))
+
+
+async def _margin_mode(mode: str):
+    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)
+
+    if mode not in ("cross", "isolated"):
+        formatter.print_error("Margin mode must be 'cross' or 'isolated'.")
+        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.set_margin_mode(mode)
+            formatter.print_raw(data)
+            if not state["json_output"]:
+                formatter.print_success(f"Margin mode set to {mode}")
+        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)

o2_cli/commands/setup_cmd.py

@@ -0,0 +1,78 @@
+"""o2 setup commands - Install skill files for vibe coding tools."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from o2_cli.setup import (
+    interactive_setup,
+    setup_tool,
+    update_skills,
+    show_skill,
+    show_status,
+    ALL_TOOLS,
+)
+
+app = typer.Typer(help="Setup and configure O2 CLI for your coding tool")
+
+
+@app.callback(invoke_without_command=True)
+def setup_main(
+    tool: Optional[str] = typer.Option(
+        None, "--tool", "-t",
+        help=f"Tool name ({', '.join(t.name for t in ALL_TOOLS)}). Interactive if omitted."
+    ),
+    scope: str = typer.Option(
+        "project", "--scope", "-s",
+        help="Install scope: global or project"
+    ),
+    update: bool = typer.Option(
+        False, "--update", "-u",
+        help="Re-install skill files for all previously configured tools"
+    ),
+    show: bool = typer.Option(
+        False, "--show-skill",
+        help="Print the full skill content"
+    ),
+    status: bool = typer.Option(
+        False, "--status",
+        help="Show current setup status"
+    ),
+):
+    """Setup O2 CLI for your vibe coding tool.
+
+    \b
+    Interactive mode:
+      o2 setup
+
+    \b
+    Non-interactive (for agents/CI):
+      o2 setup --tool claude-code --scope global
+      o2 setup --tool cursor --scope project
+
+    \b
+    Update all configured tools:
+      o2 setup --update
+
+    \b
+    Available tools: claude-code, cursor, codex, windsurf, cline, trae
+    """
+    if show:
+        show_skill()
+        return
+
+    if status:
+        show_status()
+        return
+
+    if update:
+        update_skills()
+        return
+
+    if tool:
+        setup_tool(tool, scope)
+        return
+
+    # Default: interactive wizard
+    interactive_setup()

o2_cli/commands/trades.py

@@ -0,0 +1,86 @@
+"""o2 trades commands - Trade history."""
+
+import asyncio
+from typing import Optional
+
+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="Trade history")
+
+
+@app.command("list")
+def list_trades(
+    market_id: Optional[int] = typer.Option(
+        None, "--market-id", "-m", help="Filter by market ID"
+    ),
+    limit: int = typer.Option(50, "--limit", "-n", help="Number of records"),
+    skip: int = typer.Option(0, "--skip", help="Number of records to skip"),
+):
+    """List trade history."""
+    asyncio.run(_list_trades(market_id, limit, skip))
+
+
+async def _list_trades(market_id: Optional[int], limit: int, skip: int):
+    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_trades(skip=skip, limit=limit, market_id=market_id)
+            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)
+
+
+@app.command("summary")
+def summary():
+    """Show trade summary statistics."""
+    asyncio.run(_summary())
+
+
+async def _summary():
+    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_trade_summary()
+            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)

o2_cli/commands/withdrawals.py

@@ -0,0 +1,175 @@
+"""o2 withdrawals commands - Withdrawal management."""
+
+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="Withdrawal management")
+
+
+@app.command("create")
+def create(
+    amount: str = typer.Option(..., "--amount", "-a", help="Withdrawal amount (USDC)"),
+    address: str = typer.Option(
+        ..., "--address", "-d", help="Destination wallet address"
+    ),
+    chain: str = typer.Option(
+        "ethereum", "--chain", "-c", help="Blockchain network (ethereum/base/arbitrum)"
+    ),
+    currency: str = typer.Option(
+        "USDC", "--currency", help="Currency to withdraw"
+    ),
+):
+    """Create a new withdrawal request."""
+    asyncio.run(_create(amount, address, chain, currency))
+
+
+async def _create(amount: str, address: str, chain: str, currency: str):
+    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.create_withdrawal(
+                amount=amount, address=address, chain=chain, currency=currency
+            )
+            formatter.print_raw(data)
+            if not state["json_output"]:
+                formatter.print_success(
+                    f"Withdrawal request created: {amount} {currency} to {address[:10]}..."
+                )
+        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)
+
+
+@app.command("status")
+def status(
+    id: str = typer.Option(
+        ..., "--id", "-i", help="Withdrawal ID to check"
+    ),
+):
+    """Check withdrawal status."""
+    asyncio.run(_status(id))
+
+
+async def _status(withdrawal_id: str):
+    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_withdrawal(withdrawal_id)
+            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)
+
+
+@app.command("cancel")
+def cancel(
+    id: str = typer.Option(
+        ..., "--id", "-i", help="Withdrawal ID to cancel"
+    ),
+):
+    """Cancel a pending withdrawal."""
+    asyncio.run(_cancel(id))
+
+
+async def _cancel(withdrawal_id: str):
+    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.cancel_withdrawal(withdrawal_id)
+            formatter.print_raw(data)
+            if not state["json_output"]:
+                formatter.print_success(f"Withdrawal {withdrawal_id} cancelled")
+        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)
+
+
+@app.command("list")
+def list_withdrawals(
+    limit: int = typer.Option(20, "--limit", "-n", help="Number of records"),
+    offset: int = typer.Option(0, "--offset", help="Offset"),
+):
+    """List withdrawal history."""
+    asyncio.run(_list_withdrawals(limit, offset))
+
+
+async def _list_withdrawals(limit: int, offset: int):
+    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_withdrawal_history(limit, offset)
+            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)