cometapi-cli 0.1.0__py3-none-any.whl

cometapi_cli/__init__.py

@@ -0,0 +1,3 @@
+"""CometAPI CLI — professional terminal interface for CometAPI."""
+
+__version__ = "0.1.0"

cometapi_cli/app.py

@@ -0,0 +1,85 @@
+"""CometAPI CLI — main Typer application."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import click.core
+import typer
+
+from cometapi_cli import __version__
+from cometapi_cli.formatters import OutputFormat
+
+app = typer.Typer(
+    name="cometapi",
+    help="CometAPI CLI — interact with CometAPI from the terminal.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        import sys
+
+        py_ver = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+        typer.echo(f"cometapi-cli {__version__} (python {py_ver})")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    version: Annotated[
+        bool | None,
+        typer.Option("--version", "-V", help="Show version and exit.", callback=_version_callback, is_eager=True),
+    ] = None,
+    output_format: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format."),
+    ] = OutputFormat.TABLE,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Output as JSON (shortcut for --format json)."),
+    ] = False,
+) -> None:
+    """CometAPI CLI — interact with CometAPI from the terminal."""
+    ctx.ensure_object(dict)
+    # Only set format in context when explicitly passed by user
+    if json_output:
+        ctx.obj["format"] = OutputFormat.JSON
+    elif ctx.get_parameter_source("output_format") == click.core.ParameterSource.COMMANDLINE:
+        ctx.obj["format"] = output_format
+    # Otherwise leave ctx.obj["format"] unset — resolve_format() will fall through to config file
+
+
+# Register commands
+from cometapi_cli.commands.account import account  # noqa: E402
+from cometapi_cli.commands.balance import balance  # noqa: E402
+from cometapi_cli.commands.chat import chat  # noqa: E402
+from cometapi_cli.commands.config_cmd import config_app, init  # noqa: E402
+from cometapi_cli.commands.doctor import doctor  # noqa: E402
+from cometapi_cli.commands.logs import logs  # noqa: E402
+from cometapi_cli.commands.models import models  # noqa: E402
+from cometapi_cli.commands.repl import run_repl  # noqa: E402
+from cometapi_cli.commands.stats import stats  # noqa: E402
+from cometapi_cli.commands.tasks import tasks  # noqa: E402
+from cometapi_cli.commands.tokens import tokens  # noqa: E402
+
+app.command()(chat)
+app.command()(balance)
+app.command()(models)
+app.command()(account)
+app.command()(stats)
+app.command()(tokens)
+app.command()(logs)
+app.command()(tasks)
+app.command()(init)
+app.command()(doctor)
+app.command(name="repl")(run_repl)
+app.add_typer(config_app)
+
+
+if __name__ == "__main__":
+    app()

cometapi_cli/client.py

@@ -0,0 +1,270 @@
+"""CometAPI client — inherits from OpenAI's official client."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import openai
+
+COMETAPI_BASE_URL = "https://api.cometapi.com/v1"
+COMETAPI_DASHBOARD_BASE = "https://api.cometapi.com"
+
+
+class CometClient(openai.OpenAI):
+    """Synchronous CometAPI client.
+
+    Inherits all OpenAI functionality (chat.completions, embeddings, etc.)
+    and adds CometAPI-specific endpoints.
+    """
+
+    _access_token: str | None
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        access_token: str | None = None,
+        base_url: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        api_key = api_key or os.environ.get("COMETAPI_KEY")
+        if not api_key:
+            raise openai.OpenAIError(
+                "CometAPI key is required. Pass api_key= or set COMETAPI_KEY env var."
+            )
+
+        self._access_token = access_token or os.environ.get("COMETAPI_ACCESS_TOKEN")
+
+        super().__init__(
+            api_key=api_key,
+            base_url=base_url or os.environ.get("COMETAPI_BASE_URL") or COMETAPI_BASE_URL,
+            **kwargs,
+        )
+
+    # -- Account management (access-token auth) --------------------------------
+
+    def _account_request(self, method: str, path: str, *, params: dict | None = None) -> dict:
+        """Make an authenticated request to a CometAPI account endpoint."""
+        if not self._access_token:
+            raise openai.OpenAIError(
+                "CometAPI access token is required for account endpoints. "
+                "Pass access_token= or set COMETAPI_ACCESS_TOKEN env var."
+            )
+        response = self._client.request(
+            method,
+            f"{COMETAPI_DASHBOARD_BASE}{path}",
+            headers={"Authorization": f"Bearer {self._access_token}"},
+            params=params,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def get_balance(self, *, source: str | None = None) -> dict:
+        """Get the current user's account balance."""
+        QUOTA_PER_UNIT = 500_000.0
+
+        use_user = (source == "account") or (source is None and self._access_token)
+
+        if use_user and self._access_token:
+            try:
+                resp = self._account_request("GET", "/api/user/self")
+                data = resp.get("data", resp)
+                quota = data.get("quota", 0)
+                used_quota = data.get("used_quota", 0)
+                return {
+                    "balance": quota / QUOTA_PER_UNIT,
+                    "used": used_quota / QUOTA_PER_UNIT,
+                    "total_topped_up": (quota + used_quota) / QUOTA_PER_UNIT,
+                    "currency": "USD",
+                    "source": "user",
+                }
+            except Exception:
+                if source == "account":
+                    raise
+
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        sub_resp = self._client.get(
+            f"{self.base_url}dashboard/billing/subscription",
+            headers=headers,
+        )
+        sub_resp.raise_for_status()
+        sub = sub_resp.json()
+
+        usage_resp = self._client.get(
+            f"{self.base_url}dashboard/billing/usage",
+            headers=headers,
+        )
+        usage_resp.raise_for_status()
+        usage = usage_resp.json()
+
+        hard_limit = sub.get("hard_limit_usd", 0)
+        total_usage = usage.get("total_usage", 0) / 100
+
+        if hard_limit >= 100_000_000:
+            balance = -1
+        else:
+            balance = hard_limit - total_usage
+
+        return {
+            "balance": balance,
+            "used": total_usage,
+            "total_topped_up": hard_limit if hard_limit < 100_000_000 else -1,
+            "currency": "USD",
+            "source": "billing",
+        }
+
+    def get_self(self) -> dict:
+        """Get the current user's profile (requires access token)."""
+        return self._account_request("GET", "/api/user/self")
+
+    def get_user_stats(self) -> dict:
+        """Get the current user's usage statistics (requires access token)."""
+        return self._account_request("GET", "/api/user/self/stats")
+
+    # -- Token management -------------------------------------------------------
+
+    def list_tokens(self, *, page: int = 1, page_size: int = 20) -> dict:
+        """List the user's API keys/tokens (requires access token)."""
+        return self._account_request("GET", "/api/token/", params={"p": page, "page_size": page_size})
+
+    def search_tokens(self, keyword: str = "", *, token: str = "") -> dict:
+        """Search API keys/tokens by keyword or token value (requires access token)."""
+        params: dict[str, Any] = {}
+        if keyword:
+            params["keyword"] = keyword
+        if token:
+            params["token"] = token
+        return self._account_request("GET", "/api/token/search", params=params)
+
+    # -- Logs -------------------------------------------------------------------
+
+    def list_logs(
+        self,
+        *,
+        page: int = 1,
+        page_size: int = 20,
+        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,
+    ) -> dict:
+        """List the user's usage logs (requires access token)."""
+        params: dict[str, Any] = {"p": page, "page_size": page_size}
+        if log_type is not None:
+            params["type"] = log_type
+        if model_name:
+            params["model_name"] = model_name
+        if token_name:
+            params["token_name"] = token_name
+        if start_timestamp is not None:
+            params["start_timestamp"] = start_timestamp
+        if end_timestamp is not None:
+            params["end_timestamp"] = end_timestamp
+        if group:
+            params["group"] = group
+        return self._account_request("GET", "/api/log/self", params=params)
+
+    def search_logs(self, keyword: str) -> dict:
+        """Search usage logs by keyword (requires access token)."""
+        return self._account_request("GET", "/api/log/self/search", params={"keyword": keyword})
+
+    def get_log_stat(
+        self,
+        *,
+        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,
+        request_id: str | None = None,
+    ) -> dict:
+        """Get aggregated log statistics."""
+        params: dict[str, Any] = {}
+        if log_type is not None:
+            params["type"] = log_type
+        if model_name:
+            params["model_name"] = model_name
+        if token_name:
+            params["token_name"] = token_name
+        if start_timestamp is not None:
+            params["start_timestamp"] = start_timestamp
+        if end_timestamp is not None:
+            params["end_timestamp"] = end_timestamp
+        if group:
+            params["group"] = group
+        if request_id:
+            params["request_id"] = request_id
+        return self._account_request("GET", "/api/log/self/stat", params=params)
+
+    def export_logs(
+        self,
+        *,
+        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,
+    ) -> bytes:
+        """Export usage logs as CSV (requires access token)."""
+        if not self._access_token:
+            raise openai.OpenAIError(
+                "CometAPI access token is required for account endpoints. "
+                "Pass access_token= or set COMETAPI_ACCESS_TOKEN env var."
+            )
+        params: dict[str, Any] = {}
+        if log_type is not None:
+            params["type"] = log_type
+        if model_name:
+            params["model_name"] = model_name
+        if token_name:
+            params["token_name"] = token_name
+        if start_timestamp is not None:
+            params["start_timestamp"] = start_timestamp
+        if end_timestamp is not None:
+            params["end_timestamp"] = end_timestamp
+        if group:
+            params["group"] = group
+        response = self._client.request(
+            "GET",
+            f"{COMETAPI_DASHBOARD_BASE}/api/log/self/export",
+            headers={"Authorization": f"Bearer {self._access_token}"},
+            params=params,
+        )
+        response.raise_for_status()
+        return response.content
+
+    # -- Tasks ------------------------------------------------------------------
+
+    def list_tasks(
+        self,
+        *,
+        page: int = 1,
+        page_size: int = 20,
+        platform: str | None = None,
+        task_id: str | None = None,
+        status: str | None = None,
+        action: str | None = None,
+        start_timestamp: int | None = None,
+        end_timestamp: int | None = None,
+    ) -> dict:
+        """List the user's async task logs (requires access token)."""
+        params: dict[str, Any] = {"p": page, "page_size": page_size}
+        if platform:
+            params["platform"] = platform
+        if task_id:
+            params["task_id"] = task_id
+        if status:
+            params["status"] = status
+        if action:
+            params["action"] = action
+        if start_timestamp is not None:
+            params["start_timestamp"] = start_timestamp
+        if end_timestamp is not None:
+            params["end_timestamp"] = end_timestamp
+        return self._account_request("GET", "/api/task/self", params=params)

cometapi_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CometAPI CLI commands."""

cometapi_cli/commands/account.py

@@ -0,0 +1,39 @@
+"""Account 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 account(
+    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 account profile (requires access token)."""
+    fmt = resolve_format(ctx, json_output, output_format)
+    client = get_client(require_access_token=True)
+    resp = client.get_self()
+    data = resp.get("data", {})
+
+    display = {
+        "id": data.get("id", "N/A"),
+        "username": data.get("username", "N/A"),
+        "display_name": data.get("display_name", "N/A"),
+        "email": data.get("email", "N/A"),
+        "role": data.get("role", "N/A"),
+        "status": data.get("status", "N/A"),
+    }
+
+    # For JSON output, pass raw data for maximum information
+    if fmt == OutputFormat.JSON:
+        output(data, fmt)
+    else:
+        output(display, fmt, title="CometAPI Account")

cometapi_cli/commands/balance.py

@@ -0,0 +1,56 @@
+"""Balance 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 balance(
+    ctx: typer.Context,
+    source: Annotated[
+        str | None,
+        typer.Option("--source", "-s", help="Data source: 'account' (full account) or 'token' (current API key)."),
+    ] = 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:
+    """Show your CometAPI account balance.
+
+    By default shows account-level balance (requires access token), falling back
+    to per-token billing stats. Use --source to force a specific view.
+    """
+    fmt = resolve_format(ctx, json_output, output_format)
+    client = get_client()
+    raw = client.get_balance(source=source)
+
+    # For JSON output, pass raw data for maximum information
+    if fmt == OutputFormat.JSON:
+        output(raw, fmt)
+        return
+
+    # Build human-friendly table display
+    bal = raw.get("balance", 0)
+    used = raw.get("used", 0)
+    total = raw.get("total_topped_up", 0)
+    data_source = raw.get("source", "unknown")
+
+    if data_source == "billing":
+        display: dict[str, str] = {
+            "limit": f"${bal:,.2f}" if bal >= 0 else "Unlimited",
+            "used": f"${used:,.2f}",
+        }
+    else:
+        display = {
+            "available_balance": f"${bal:,.2f}" if bal >= 0 else "Unlimited",
+            "used": f"${used:,.2f}",
+            "total_topped_up": f"${total:,.2f}" if total >= 0 else "N/A",
+        }
+
+    output(display, fmt, title="CometAPI Balance")

cometapi_cli/commands/chat.py

@@ -0,0 +1,104 @@
+"""Chat command."""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Annotated
+
+import typer
+
+from ..config import get_client, get_default_model
+from ..errors import handle_errors
+from ..formatters import OutputFormat, resolve_format
+
+
+@handle_errors
+def chat(
+    ctx: typer.Context,
+    message: Annotated[str | None, typer.Argument(help="Message to send. Omit to enter interactive REPL.")] = None,
+    model: Annotated[str | None, typer.Option("--model", "-m", help="Model to use.")] = None,
+    system: Annotated[str | None, typer.Option("--system", "-s", help="System prompt.")] = None,
+    temperature: Annotated[float | None, typer.Option("--temperature", "-t", help="Sampling temperature.")] = None,
+    max_tokens: Annotated[int | None, typer.Option("--max-tokens", help="Max tokens in response.")] = None,
+    stream: Annotated[bool, typer.Option("--stream/--no-stream", help="Stream output.")] = True,
+    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:
+    """Send a chat message, or start interactive REPL (no args)."""
+    # No message → enter REPL mode
+    if message is None:
+        from .chat_repl import run_chat_repl
+
+        run_chat_repl(
+            model=model,
+            system=system,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stream=stream,
+        )
+        return
+
+    from rich.markdown import Markdown
+
+    from ..console import console
+
+    fmt = resolve_format(ctx, json_output, output_format)
+    client = get_client()
+    resolved_model = model or get_default_model()
+
+    messages: list[dict[str, str]] = []
+    if system:
+        messages.append({"role": "system", "content": system})
+    messages.append({"role": "user", "content": message})
+
+    kwargs: dict = {"model": resolved_model, "messages": messages}
+    if temperature is not None:
+        kwargs["temperature"] = temperature
+    if max_tokens is not None:
+        kwargs["max_tokens"] = max_tokens
+
+    # JSON output: disable streaming, return structured data
+    if fmt == OutputFormat.JSON:
+        kwargs["stream"] = False
+        response = client.chat.completions.create(**kwargs)
+        text = response.choices[0].message.content or ""
+        print(
+            json.dumps(
+                {
+                    "model": getattr(response, "model", resolved_model),
+                    "role": "assistant",
+                    "content": text,
+                    "usage": {
+                        "prompt_tokens": getattr(response.usage, "prompt_tokens", None),
+                        "completion_tokens": getattr(response.usage, "completion_tokens", None),
+                        "total_tokens": getattr(response.usage, "total_tokens", None),
+                    },
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+        )
+        return
+
+    # Interactive output
+    if stream:
+        kwargs["stream"] = True
+        stream_response = client.chat.completions.create(**kwargs)
+        full_text = ""
+        for chunk in stream_response:
+            if not chunk.choices:
+                continue
+            delta = chunk.choices[0].delta.content or ""
+            sys.stdout.write(delta)
+            sys.stdout.flush()
+            full_text += delta
+        sys.stdout.write("\n")
+        sys.stdout.flush()
+        console.print(f"[dim]Model: {resolved_model}[/dim]")
+    else:
+        kwargs["stream"] = False
+        response = client.chat.completions.create(**kwargs)
+        text = response.choices[0].message.content or ""
+        console.print(Markdown(text))
+        console.print(f"[dim]Model: {getattr(response, 'model', resolved_model)}[/dim]")