cometapi-cli 0.1.0__py3-none-any.whl

cometapi_cli/commands/logs.py

@@ -0,0 +1,326 @@
+"""Usage logs command."""
+
+from __future__ import annotations
+
+import json as _json
+import sys
+from typing import Annotated
+
+import typer
+
+from ..config import get_client
+from ..constants import extract_items, format_ts, parse_date, quota_to_usd
+from ..errors import handle_errors
+from ..formatters import OutputFormat, output, resolve_format
+
+LOG_TYPE_MAP = {
+    "unknown": 0,
+    "topup": 1,
+    "consume": 2,
+    "manage": 3,
+    "system": 4,
+    "error": 5,
+    "refund": 6,
+}
+
+_LOG_TYPE_NAMES = {v: k for k, v in LOG_TYPE_MAP.items()}
+
+
+def _parse_other(other_raw: str | None) -> dict:
+    """Parse the ``other`` JSON string from a log entry, returning {} on failure."""
+    if not other_raw:
+        return {}
+    try:
+        parsed = _json.loads(other_raw)
+        return parsed if isinstance(parsed, dict) else {}
+    except (ValueError, TypeError):
+        return {}
+
+
+def _find_log_by_id(
+    client: object,
+    *,
+    request_id: str,
+    log_type: int | None = None,
+    model_name: str | None = None,
+    token_name: str | None = None,
+    start_timestamp: int | None = None,
+    end_timestamp: int | None = None,
+    group: str | None = None,
+    max_pages: int = 10,
+) -> dict | None:
+    """Search through paginated logs to find the entry matching a request ID."""
+    for pg in range(1, max_pages + 1):
+        resp = client.list_logs(  # type: ignore[union-attr]
+            page=pg,
+            page_size=100,
+            log_type=log_type,
+            model_name=model_name,
+            token_name=token_name,
+            start_timestamp=start_timestamp,
+            end_timestamp=end_timestamp,
+            group=group,
+        )
+        items = extract_items(resp)
+        if not items:
+            break
+        for item in items:
+            if item.get("request_id") == request_id:
+                return item
+    return None
+
+
+def _format_log_detail(log: dict) -> dict:
+    """Build a rich key-value detail card from a single log entry."""
+    other = _parse_other(log.get("other"))
+    prompt_tokens = log.get("prompt_tokens", 0)
+    completion_tokens = log.get("completion_tokens", 0)
+    quota = log.get("quota", 0)
+
+    info: dict[str, str | int | float] = {}
+    info["Request ID"] = log.get("request_id", "") or "—"
+    info["Response ID"] = log.get("response_id", "") or "—"
+    info["Time"] = format_ts(log.get("created_at", 0))
+    info["Model"] = log.get("model_name", "") or "—"
+    info["Token Name"] = log.get("token_name", "") or "—"
+    info["Group"] = log.get("group", "") or "—"
+    info["Stream"] = "Yes" if log.get("is_stream") else "No"
+
+    # Tokens
+    info["Prompt Tokens"] = f"{prompt_tokens:,}"
+    info["Completion Tokens"] = f"{completion_tokens:,}"
+    cache_tokens = other.get("cache_tokens", 0)
+    if cache_tokens:
+        info["Cache Tokens"] = f"{cache_tokens:,}"
+
+    # Cost
+    info["Cost (USD)"] = quota_to_usd(quota)
+    info["Quota (raw)"] = f"{quota:,}"
+
+    # Pricing breakdown from 'other'
+    model_ratio = other.get("model_ratio")
+    if model_ratio is not None:
+        info["Model Ratio"] = model_ratio
+    completion_ratio = other.get("completion_ratio")
+    if completion_ratio is not None:
+        info["Completion Ratio"] = f"{completion_ratio}x"
+    group_ratio = other.get("group_ratio")
+    if group_ratio is not None:
+        info["Group Ratio"] = group_ratio
+    model_price = other.get("model_price")
+    if model_price is not None:
+        info["Model Price"] = "default" if model_price == -1 else model_price
+    cache_ratio = other.get("cache_ratio")
+    if cache_ratio is not None:
+        info["Cache Ratio"] = cache_ratio
+
+    # Timing
+    use_time = log.get("use_time", 0)
+    info["Duration"] = f"{use_time:,} ms" if use_time else "—"
+    frt = other.get("frt")
+    if frt and frt > 0:
+        info["First Token"] = f"{frt:,} ms"
+
+    # Path
+    request_path = other.get("request_path")
+    if request_path:
+        info["Endpoint"] = request_path
+
+    return info
+
+
+def _format_log_row(log: dict, *, detail: bool = False) -> dict:
+    row: dict = {
+        "time": format_ts(log.get("created_at", 0)),
+        "type": _LOG_TYPE_NAMES.get(log.get("type", 0), "unknown"),
+        "model": log.get("model_name", "") or "—",
+        "token": log.get("token_name", "") or "—",
+        "prompt": log.get("prompt_tokens", 0),
+        "completion": log.get("completion_tokens", 0),
+        "cost": quota_to_usd(log.get("quota", 0)),
+        "duration_ms": log.get("use_time", 0),
+        "stream": "Yes" if log.get("is_stream") else "No",
+    }
+    if detail:
+        row["request_id"] = log.get("request_id", "") or "—"
+        row["response_id"] = log.get("response_id", "") or "—"
+        other = _parse_other(log.get("other"))
+        row["model_ratio"] = other.get("model_ratio", "—")
+        row["group_ratio"] = other.get("group_ratio", "—")
+        row["completion_ratio"] = other.get("completion_ratio", "—")
+        model_price = other.get("model_price")
+        row["model_price"] = model_price if model_price is not None else "—"
+    return row
+
+
+@handle_errors
+def logs(
+    ctx: typer.Context,
+    model: Annotated[str | None, typer.Option("--model", "-m", help="Filter by model name.")] = None,
+    token_name: Annotated[str | None, typer.Option("--token-name", "-t", help="Filter by token name.")] = None,
+    log_type: Annotated[
+        str | None,
+        typer.Option("--type", help="Filter by type: consume, topup, error, refund, manage, system."),
+    ] = None,
+    search: Annotated[str | None, typer.Option("--search", "-s", help="[deprecated] Search logs by keyword.")] = None,
+    start: Annotated[str | None, typer.Option("--start", help="Start date (YYYY-MM-DD, ISO 8601, or Unix ts).")] = None,
+    end: Annotated[str | None, typer.Option("--end", help="End date (YYYY-MM-DD, ISO 8601, or Unix ts).")] = None,
+    group: Annotated[str | None, typer.Option("--group", "-g", help="Filter by group.")] = None,
+    request_id: Annotated[
+        str | None,
+        typer.Option("--request-id", help="Look up cost by request ID (X-Cometapi-Request-Id header)."),
+    ] = None,
+    detail: Annotated[
+        bool,
+        typer.Option("--detail", help="Show extended columns (request ID, pricing ratios)."),
+    ] = False,
+    page: Annotated[int, typer.Option("--page", "-p", help="Page number.")] = 1,
+    limit: Annotated[int, typer.Option("--limit", "-l", help="Results per page.")] = 20,
+    export: Annotated[bool, typer.Option("--export", help="Export logs as CSV to stdout.")] = False,
+    output_format: Annotated[OutputFormat | None, typer.Option("--format", "-f", help="Output format.")] = None,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON.")] = False,
+) -> None:
+    """Show your usage logs (requires access token)."""
+    from ..console import console, err_console
+
+    fmt = resolve_format(ctx, json_output, output_format)
+    client = get_client(require_access_token=True)
+
+    # Parse date options
+    start_ts = parse_date(start, "start") if start else None
+    end_ts = parse_date(end, "end") if end else None
+
+    # --request-id: find the full log entry and display detail card
+    if request_id:
+        if export:
+            err_console.print("[red]--request-id cannot be used with --export.[/]")
+            raise typer.Exit(code=2)
+
+        type_int = None
+        if log_type:
+            type_int = LOG_TYPE_MAP.get(log_type.lower())
+
+        log_entry = _find_log_by_id(
+            client,
+            request_id=request_id,
+            log_type=type_int,
+            model_name=model,
+            token_name=token_name,
+            start_timestamp=start_ts,
+            end_timestamp=end_ts,
+            group=group,
+        )
+
+        if log_entry is None:
+            err_console.print(
+                f"[red]No log found for request_id=[/]{request_id}\n"
+                "[dim]The entry may be older than the search window. "
+                "Try narrowing with --start/--end or --model.[/]"
+            )
+            raise typer.Exit(code=1)
+
+        if fmt == OutputFormat.JSON:
+            output(log_entry, fmt)
+            return
+
+        info = _format_log_detail(log_entry)
+        output(info, fmt, title="Request Detail")
+        return
+
+    # Server-side CSV export — write raw bytes to stdout and return early
+    if export:
+        type_int = None
+        if log_type:
+            type_int = LOG_TYPE_MAP.get(log_type.lower())
+            if type_int is None:
+                valid = ", ".join(LOG_TYPE_MAP.keys())
+                err_console.print(f"[red]Invalid log type:[/] {log_type}. Valid types: {valid}")
+                raise typer.Exit(code=2)
+        csv_bytes = client.export_logs(
+            log_type=type_int,
+            model_name=model,
+            token_name=token_name,
+            start_timestamp=start_ts,
+            end_timestamp=end_ts,
+            group=group,
+        )
+        sys.stdout.buffer.write(csv_bytes)
+        return
+
+    if search:
+        err_console.print(
+            "[yellow]Warning:[/] --search only matches log type codes on the server, "
+            "not keywords. Use --request-id, --model, or --token-name for filtering."
+        )
+        ignored = []
+        if model:
+            ignored.append("--model")
+        if token_name:
+            ignored.append("--token-name")
+        if log_type:
+            ignored.append("--type")
+        if start:
+            ignored.append("--start")
+        if end:
+            ignored.append("--end")
+        if group:
+            ignored.append("--group")
+        if page != 1:
+            ignored.append("--page")
+        if limit != 20:
+            ignored.append("--limit")
+        if ignored:
+            err_console.print(
+                f"[yellow]Warning:[/] --search ignores other filters: {', '.join(ignored)}"
+            )
+        resp = client.search_logs(keyword=search)
+    else:
+        type_int = None
+        if log_type:
+            type_int = LOG_TYPE_MAP.get(log_type.lower())
+            if type_int is None:
+                valid = ", ".join(LOG_TYPE_MAP.keys())
+                err_console.print(f"[red]Invalid log type:[/] {log_type}. Valid types: {valid}")
+                raise typer.Exit(code=2)
+
+        resp = client.list_logs(
+            page=page,
+            page_size=limit,
+            log_type=type_int,
+            model_name=model,
+            token_name=token_name,
+            start_timestamp=start_ts,
+            end_timestamp=end_ts,
+            group=group,
+        )
+
+    data = extract_items(resp)
+
+    if fmt == OutputFormat.JSON:
+        output(data, fmt)
+        return
+
+    if not data:
+        console.print("[dim]No logs found.[/]")
+        return
+
+    rows = [_format_log_row(log, detail=detail) for log in data]
+    columns: dict[str, str] = {
+        "time": "dim",
+        "type": "cyan",
+        "model": "green",
+        "token": "yellow",
+        "prompt": "green",
+        "completion": "green",
+        "cost": "red",
+        "duration_ms": "dim",
+        "stream": "dim",
+    }
+    if detail:
+        columns["request_id"] = "blue"
+        columns["response_id"] = "blue"
+        columns["model_ratio"] = "magenta"
+        columns["group_ratio"] = "magenta"
+        columns["completion_ratio"] = "magenta"
+        columns["model_price"] = "magenta"
+    output(rows, fmt, title="Usage Logs", columns=columns)

cometapi_cli/commands/models.py

@@ -0,0 +1,44 @@
+"""Models command."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from ..config import get_client
+from ..errors import handle_errors
+from ..formatters import OutputFormat, output, resolve_format
+
+
+@handle_errors
+def models(
+    ctx: typer.Context,
+    search: Annotated[str | None, typer.Option("--search", "-s", help="Filter models by name.")] = None,
+    limit: Annotated[int | None, typer.Option("--limit", "-l", help="Max number of models to show.")] = None,
+    output_format: Annotated[OutputFormat | None, typer.Option("--format", "-f", help="Output format.")] = None,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON.")] = False,
+) -> None:
+    """List available models."""
+    fmt = resolve_format(ctx, json_output, output_format)
+    client = get_client()
+    result = client.models.list()
+
+    rows = sorted(
+        [{"id": m.id, "owned_by": m.owned_by} for m in result],
+        key=lambda r: r["id"],
+    )
+
+    if search:
+        term = search.lower()
+        rows = [r for r in rows if term in r["id"].lower()]
+
+    if limit and limit > 0:
+        rows = rows[:limit]
+
+    output(
+        rows,
+        fmt,
+        title=f"Available Models ({len(rows)})",
+        columns={"id": "cyan", "owned_by": "green"},
+    )

cometapi_cli/commands/repl.py

@@ -0,0 +1,134 @@
+"""Interactive command REPL for CometAPI CLI."""
+
+from __future__ import annotations
+
+import shlex
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.history import FileHistory
+from rich.panel import Panel
+from rich.text import Text
+
+from ..config import CONFIG_DIR, get_value, mask_secret
+from ..console import console
+from ..errors import handle_errors
+
+REPL_COMMANDS = [
+    "chat", "models", "balance", "account", "stats",
+    "tokens", "logs", "tasks",
+    "doctor", "init", "config", "help", "exit", "quit",
+]
+
+
+def _repl_banner() -> Panel:
+    from cometapi_cli import __version__
+
+    api_key = get_value("api_key", "COMETAPI_KEY")
+    key_display = mask_secret(api_key) if api_key else "[not set]"
+
+    text = Text.assemble(
+        ("CometAPI REPL", "bold cyan"),
+        (f"  v{__version__}", "dim"),
+        "\n",
+        ("API Key: ", "dim"),
+        (key_display, "green" if api_key else "red"),
+        "\n",
+        ("Type any command without 'cometapi' prefix. 'help' for commands, 'exit' to quit.", "dim"),
+    )
+    return Panel(text, border_style="cyan", padding=(0, 1))
+
+
+def _show_help() -> None:
+    console.print("\n[bold]Available commands:[/]")
+    console.print("  [cyan]chat [message][/]    Send a message or start chat REPL")
+    console.print("  [cyan]models[/]            List available models")
+    console.print("  [cyan]balance[/]           Show account balance")
+    console.print("  [cyan]account[/]           Show account info")
+    console.print("  [cyan]stats[/]             Show usage statistics")
+    console.print("  [cyan]tokens[/]            List your API keys")
+    console.print("  [cyan]logs[/]              Show usage logs")
+    console.print("  [cyan]tasks[/]             Show async task logs")
+    console.print("  [cyan]doctor[/]            Run diagnostics")
+    console.print("  [cyan]init[/]              Run setup wizard")
+    console.print("  [cyan]config ...[/]        Manage configuration")
+    console.print("  [cyan]help[/]              Show this help")
+    console.print("  [cyan]exit[/]              Exit REPL")
+    console.print()
+
+
+@handle_errors
+def run_repl() -> None:
+    """Start interactive command REPL."""
+    import sys
+
+    console.print(_repl_banner())
+
+    history_file = CONFIG_DIR / "repl_history"
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+    completer = WordCompleter(
+        REPL_COMMANDS + [
+            "--json", "--format", "--model", "--system",
+            "--search", "--limit", "--help", "--page",
+            "--type", "--token-name", "--start", "--end",
+            "--group", "--export", "--platform", "--task-id",
+            "--status", "--action",
+        ],
+        ignore_case=True,
+    )
+
+    session: PromptSession[str] = PromptSession(
+        history=FileHistory(str(history_file)),
+        completer=completer,
+    )
+
+    while True:
+        try:
+            user_input = session.prompt(HTML("<b><ansicyan>cometapi → </ansicyan></b>")).strip()
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n[dim]Goodbye![/]")
+            break
+
+        if not user_input:
+            continue
+
+        if user_input.lower() in ("exit", "quit", "q"):
+            console.print("[dim]Goodbye![/]")
+            break
+
+        if user_input.lower() == "help":
+            _show_help()
+            continue
+
+        # Parse the input and dispatch through the Typer app
+        try:
+            args = shlex.split(user_input)
+        except ValueError as e:
+            console.print(f"[red]Parse error: {e}[/]")
+            continue
+
+        # Strip leading "cometapi" if user types it by habit
+        if args and args[0] == "cometapi":
+            args = args[1:]
+
+        if not args:
+            continue
+
+        # Prevent recursive REPL
+        if args[0] == "repl":
+            console.print("[yellow]Already in REPL mode.[/]")
+            continue
+
+        from ..app import app
+
+        try:
+            app(args, standalone_mode=False)
+        except SystemExit:
+            pass
+        except Exception as e:
+            console.print(f"[red bold]Error:[/] {e}")
+
+        # Reset stdout in case streaming left it in a bad state
+        sys.stdout.flush()

cometapi_cli/commands/stats.py

@@ -0,0 +1,39 @@
+"""Stats command."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from ..config import get_client
+from ..errors import handle_errors
+from ..formatters import OutputFormat, output, resolve_format
+
+
+@handle_errors
+def stats(
+    ctx: typer.Context,
+    output_format: Annotated[OutputFormat | None, typer.Option("--format", "-f", help="Output format.")] = None,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON.")] = False,
+) -> None:
+    """Show your CometAPI usage statistics (requires access token)."""
+    fmt = resolve_format(ctx, json_output, output_format)
+    client = get_client(require_access_token=True)
+    resp = client.get_user_stats()
+    data = resp.get("data", {})
+
+    display = {
+        "requests": data.get("month_req_count", "N/A"),
+        "request_rate_change": f"{data.get('req_rate', 0):.1f}%",
+        "usage": f"${data.get('month_usage', 0):.4f}",
+        "usage_rate_change": f"{data.get('usage_rate', 0):.1f}%",
+        "success_rate": f"{data.get('month_success_rate', 0):.1f}%",
+        "predicted_days_left": data.get("predicted_days", "N/A"),
+    }
+
+    # For JSON output, pass raw data for maximum information
+    if fmt == OutputFormat.JSON:
+        output(data, fmt)
+    else:
+        output(display, fmt, title="CometAPI Usage Statistics (This Month)")

cometapi_cli/commands/tasks.py

@@ -0,0 +1,130 @@
+"""Task logs command — async tasks (Suno, Midjourney, Luma, Kling, etc.)."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from ..config import get_client
+from ..constants import extract_items, format_ts, parse_date, quota_to_usd
+from ..errors import handle_errors
+from ..formatters import OutputFormat, output, resolve_format
+
+VALID_PLATFORMS = [
+    "suno", "mj", "luma", "replicate", "kling",
+    "runwayml", "runway", "jimeng", "volcengine", "sora", "bria", "flux",
+]
+
+VALID_STATUSES = [
+    "SUBMITTED", "QUEUED", "IN_PROGRESS", "FAILURE", "SUCCESS", "UNKNOWN",
+]
+
+
+def _duration(submit_ts: int, finish_ts: int) -> str:
+    """Calculate human-readable duration between two timestamps."""
+    if not submit_ts or not finish_ts:
+        return "—"
+    secs = finish_ts - submit_ts
+    if secs < 0:
+        return "—"
+    if secs < 60:
+        return f"{secs}s"
+    mins = secs // 60
+    remaining = secs % 60
+    return f"{mins}m{remaining}s"
+
+
+def _format_task_row(task: dict) -> dict:
+    return {
+        "time": format_ts(task.get("created_at", 0)),
+        "platform": task.get("platform", "") or "—",
+        "task_id": task.get("task_id", "") or "—",
+        "action": task.get("action", "") or "—",
+        "status": task.get("status", "") or "—",
+        "model": task.get("model_name", "") or "—",
+        "progress": task.get("progress", "") or "—",
+        "cost": quota_to_usd(task.get("quota", 0)),
+        "duration": _duration(task.get("submit_time", 0), task.get("finish_time", 0)),
+    }
+
+
+@handle_errors
+def tasks(
+    ctx: typer.Context,
+    platform: Annotated[
+        str | None,
+        typer.Option("--platform", "-p", help=f"Filter by platform: {', '.join(VALID_PLATFORMS)}."),
+    ] = None,
+    task_id: Annotated[str | None, typer.Option("--task-id", help="Filter by task ID.")] = None,
+    status: Annotated[
+        str | None,
+        typer.Option("--status", "-s", help=f"Filter by status: {', '.join(VALID_STATUSES)}."),
+    ] = None,
+    action: Annotated[str | None, typer.Option("--action", "-a", help="Filter by action type.")] = None,
+    start: Annotated[str | None, typer.Option("--start", help="Start date (YYYY-MM-DD, ISO 8601, or Unix ts).")] = None,
+    end: Annotated[str | None, typer.Option("--end", help="End date (YYYY-MM-DD, ISO 8601, or Unix ts).")] = None,
+    page: Annotated[int, typer.Option("--page", help="Page number.")] = 1,
+    limit: Annotated[int, typer.Option("--limit", "-l", help="Results per page.")] = 20,
+    output_format: Annotated[OutputFormat | None, typer.Option("--format", "-f", help="Output format.")] = None,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON.")] = False,
+) -> None:
+    """Show your async task logs — Suno, MJ, Luma, Kling, etc. (requires access token)."""
+    fmt = resolve_format(ctx, json_output, output_format)
+    client = get_client(require_access_token=True)
+
+    # Validate platform
+    if platform and platform.lower() not in VALID_PLATFORMS:
+        from ..console import err_console
+
+        valid = ", ".join(VALID_PLATFORMS)
+        err_console.print(f"[red]Invalid platform:[/] {platform}. Valid platforms: {valid}")
+        raise typer.Exit(code=2)
+
+    # Validate status
+    if status and status.upper() not in VALID_STATUSES:
+        from ..console import err_console
+
+        valid = ", ".join(VALID_STATUSES)
+        err_console.print(f"[red]Invalid status:[/] {status}. Valid statuses: {valid}")
+        raise typer.Exit(code=2)
+
+    start_ts = parse_date(start, "start") if start else None
+    end_ts = parse_date(end, "end") if end else None
+
+    resp = client.list_tasks(
+        page=page,
+        page_size=limit,
+        platform=platform.lower() if platform else None,
+        task_id=task_id,
+        status=status.upper() if status else None,
+        action=action,
+        start_timestamp=start_ts,
+        end_timestamp=end_ts,
+    )
+
+    data = extract_items(resp)
+
+    if fmt == OutputFormat.JSON:
+        output(data, fmt)
+        return
+
+    if not data:
+        from ..console import console
+
+        console.print("[dim]No tasks found.[/]")
+        return
+
+    rows = [_format_task_row(t) for t in data]
+    columns = {
+        "time": "dim",
+        "platform": "magenta",
+        "task_id": "cyan",
+        "action": "yellow",
+        "status": "green",
+        "model": "green",
+        "progress": "dim",
+        "cost": "red",
+        "duration": "dim",
+    }
+    output(rows, fmt, title="Task Logs", columns=columns)